package mandreelFile3;

import static Class.CommonClassFile.commonVariable;
import static Class.CommonClassFile.heapClassInst;
import static Class.DevNumber.*;
import static commonFile.CommonFile.*;
import static mandreelFile4.mandreelFile4.znk16btCollisionShape21calculateTemporalAabbERK11btTransformRK9btVector3S5FRS3S6;
import static mandreelFile5.mandreelFile5.*;

public class mandreelFile3 {

    public static void zn14btQuantizedBvh16deSerializeFloatER23btQuantizedBvhFloatData(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        int r6 = 0;
        int r7 = 0;
        int r8 = 0;
        int r9 = 0;
        int r10 = 0;
        int r11 = 0;
        int r12 = 0;
        int r13 = 0;
        int r14 = 0;
        int r15 = 0;
        int r16 = 0;
        int r17 = 0;
        int r18 = 0;
        int label = 0;
        i7 = sp + numDefineNeg16;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = heapClassInst.heap32[fp + 1];
        r1 = r1 >> numDefine2;
        r2 = r0 >> numDefine2;
        heapClassInst.heap32[r2 + numDefine5] = heapClassInst.heap32[r1 + numDefine4];
        heapClassInst.heap32[r2 + numDefine6] = heapClassInst.heap32[r1 + numDefine5];
        heapClassInst.heap32[r2 + numDefine7] = heapClassInst.heap32[r1 + numDefine6];
        heapClassInst.heap32[r2 + numDefine8] = heapClassInst.heap32[r1 + numDefine7];
        heapClassInst.heap32[r2 + 1] = heapClassInst.heap32[r1];
        heapClassInst.heap32[r2 + numDefine2] = heapClassInst.heap32[r1 + 1];
        heapClassInst.heap32[r2 + numDefine3] = heapClassInst.heap32[r1 + numDefine2];
        heapClassInst.heap32[r2 + numDefine4] = heapClassInst.heap32[r1 + numDefine3];
        heapClassInst.heap32[r2 + numDefine9] = heapClassInst.heap32[r1 + numDefine8];
        heapClassInst.heap32[r2 + numDefine10] = heapClassInst.heap32[r1 + numDefine9];
        heapClassInst.heap32[r2 + numDefine11] = heapClassInst.heap32[r1 + numDefine10];
        heapClassInst.heap32[r2 + numDefine12] = heapClassInst.heap32[r1 + numDefine11];
        r3 = heapClassInst.heap32[r1 + numDefine12];
        heapClassInst.heap32[r2 + numDefine14] = r3;
        r3 = 0;
        r4 = heapClassInst.heap32[r1 + numDefine13];
        r4 = r4 != r3 ? 1 : 0;
        r4 = r4 & 1;
        heapClassInst.heap8[r0 + numDefine60] = (byte) r4;
        r4 = heapClassInst.heap32[r2 + numDefine22];
        r5 = heapClassInst.heap32[r1 + numDefine14];
        if (!(r4 >= r5)) {
            r6 = heapClassInst.heap32[r2 + numDefine23];
            if (!(r6 >= r5)) {
                if (r5 != 0) {
                    r6 = gNumAlignedAllocs;
                    r6 = r6 >> numDefine2;
                    r7 = heapClassInst.heap32[r6];
                    r7 = (r7 + 1) | 0;
                    r8 = r5 << numDefine6;
                    heapClassInst.heap32[r6] = r7;
                    r6 = r8 | numDefine19;
                    heapClassInst.heap32[g0] = r6;
                    mallocNew(i7);
                    r6 = commonVariable.rg0;
                    if (r6 != 0) {
                        r7 = 0;
                        r8 = (r6 + numDefine4) | 0;
                        r7 = (r7 - r8) | 0;
                        r7 = r7 & numDefine15;
                        r7 = (r6 + r7) | 0;
                        r8 = (r7 + numDefine4) | 0;
                        r7 = r7 >> numDefine2;
                        heapClassInst.heap32[r7] = r6;
                        r6 = r8;
                    }
                } else {
                    r6 = 0;
                }
                r7 = (r0 + numDefine96) | 0;
                if (r4 < 1) {
                    r4 = r7 >> numDefine2;
                    r9 = heapClassInst.heap32[r4];
                } else {
                    r8 = 0;
                    repeat12:
                    while (true) {
                        r9 = r7 >> numDefine2;
                        r9 = heapClassInst.heap32[r9];
                        r10 = (r6 + r8) | 0;
                        r11 = (r9 + r8) | 0;
                        heapClassInst.heap32[g0] = r10;
                        heapClassInst.heap32[g0 + 1] = r11;
                        heapClassInst.heap32[g0 + numDefine2] = numDefine64;
                        r4 = (r4 + -1) | 0;
                        r8 = (r8 + numDefine64) | 0;
                        memcpy(i7);
                        if (!(r4 != 0)) {
                            break repeat12;
                        }
                    }
                    r7 = (r0 + numDefine96) | 0;
                }
                if (!(r9 == 0)) {
                    r4 = heapClassInst.heapU8[r0 + numDefine100];
                    if (!(r4 == 0)) {
                        r4 = gNumAlignedFree;
                        r4 = r4 >> numDefine2;
                        r8 = heapClassInst.heap32[r4];
                        r8 = (r8 + 1) | 0;
                        r9 = r9 >> numDefine2;
                        heapClassInst.heap32[r4] = r8;
                        r4 = heapClassInst.heap32[r9 + -1];
                        heapClassInst.heap32[g0] = r4;
                        free(i7);
                    }
                    r4 = r7 >> numDefine2;
                    heapClassInst.heap32[r4] = 0;
                }
                r4 = 1;
                r7 = r7 >> numDefine2;
                heapClassInst.heap8[r0 + numDefine100] = (byte) r4;
                heapClassInst.heap32[r7] = r6;
                heapClassInst.heap32[r2 + numDefine23] = r5;
            }
        }
        heapClassInst.heap32[r2 + numDefine22] = r5;
        repeat23:
        do {
            if (!(r5 < 1)) {
                r4 = 0;
                r6 = heapClassInst.heap32[r1 + numDefine16];
                r5 = (r4 - r5) | 0;
                repeat25:
                while (true) {
                    r7 = (r4 * numDefineNeg12) | 0;
                    r7 = r7 << numDefine2;
                    r8 = r4 << numDefine6;
                    r9 = heapClassInst.heap32[r2 + numDefine24];
                    r7 = (r6 + r7) | 0;
                    r9 = (r9 - r8) | 0;
                    r7 = r7 >> numDefine2;
                    r9 = r9 >> numDefine2;
                    heapClassInst.heap32[r9 + numDefine4] = heapClassInst.heap32[r7 + numDefine4];
                    heapClassInst.heap32[r9 + numDefine5] = heapClassInst.heap32[r7 + numDefine5];
                    heapClassInst.heap32[r9 + numDefine6] = heapClassInst.heap32[r7 + numDefine6];
                    heapClassInst.heap32[r9 + numDefine7] = heapClassInst.heap32[r7 + numDefine7];
                    r9 = heapClassInst.heap32[r2 + numDefine24];
                    r9 = (r9 - r8) | 0;
                    r9 = r9 >> numDefine2;
                    heapClassInst.heap32[r9] = heapClassInst.heap32[r7];
                    heapClassInst.heap32[r9 + 1] = heapClassInst.heap32[r7 + 1];
                    heapClassInst.heap32[r9 + numDefine2] = heapClassInst.heap32[r7 + numDefine2];
                    heapClassInst.heap32[r9 + numDefine3] = heapClassInst.heap32[r7 + numDefine3];
                    r9 = heapClassInst.heap32[r2 + numDefine24];
                    r9 = (r9 - r8) | 0;
                    r10 = heapClassInst.heap32[r7 + numDefine8];
                    r9 = r9 >> numDefine2;
                    heapClassInst.heap32[r9 + numDefine8] = r10;
                    r9 = heapClassInst.heap32[r2 + numDefine24];
                    r9 = (r9 - r8) | 0;
                    r10 = heapClassInst.heap32[r7 + numDefine9];
                    r9 = r9 >> numDefine2;
                    heapClassInst.heap32[r9 + numDefine9] = r10;
                    r9 = heapClassInst.heap32[r2 + numDefine24];
                    r8 = (r9 - r8) | 0;
                    r7 = heapClassInst.heap32[r7 + numDefine10];
                    r4 = (r4 + -1) | 0;
                    r8 = r8 >> numDefine2;
                    heapClassInst.heap32[r8 + numDefine10] = r7;
                    if (r5 != r4) {
                        continue repeat25;
                    } else {
                        break repeat23;
                    }
                }
            }
        } while (false);
        r4 = heapClassInst.heap32[r2 + numDefine32];
        r5 = heapClassInst.heap32[r1 + numDefine15];
        repeat28:
        do {
            if (!(r4 >= r5)) {
                r6 = (r0 + numDefine124) | 0;
                heapClassInst.heap32[g0] = r6;
                heapClassInst.heap32[g0 + 1] = r5;
                r6 = (r5 - r4) | 0;
                r4 = r4 << numDefine4;
                zn20btAlignedObjectArrayI18btQuantizedBvhNodeE7reserveEi(i7);
                repeat30:
                while (true) {
                    r7 = heapClassInst.heap32[r2 + numDefine34];
                    r7 = (r7 + r4) | 0;
                    r7 = r7 >> numDefine2;
                    r6 = (r6 + -1) | 0;
                    r4 = (r4 + numDefine16) | 0;
                    heapClassInst.heap32[r7] = 0;
                    heapClassInst.heap32[r7 + 1] = 0;
                    heapClassInst.heap32[r7 + numDefine2] = 0;
                    heapClassInst.heap32[r7 + numDefine3] = 0;
                    if (r6 != 0) {
                        continue repeat30;
                    } else {
                        break repeat28;
                    }
                }
            }
        } while (false);
        heapClassInst.heap32[r2 + numDefine32] = r5;
        repeat33:
        do {
            if (!(r5 < 1)) {
                r4 = 0;
                r6 = heapClassInst.heap32[r1 + numDefine17];
                r5 = (r4 - r5) | 0;
                repeat35:
                while (true) {
                    r7 = r4 << numDefine4;
                    r8 = (r6 - r7) | 0;
                    r9 = r8 >> numDefine2;
                    r10 = heapClassInst.heap32[r2 + numDefine34];
                    r10 = (r10 - r7) | 0;
                    r9 = heapClassInst.heap32[r9 + numDefine3];
                    r10 = r10 >> numDefine2;
                    heapClassInst.heap32[r10 + numDefine3] = r9;
                    r9 = heapClassInst.heap32[r2 + numDefine34];
                    r10 = heapClassInst.heapU16[(r8 + numDefine6) >> 1];
                    r9 = (r9 - r7) | 0;
                    heapClassInst.heap16[(r9 + numDefine6) >> 1] = (short) r10;
                    r9 = heapClassInst.heap32[r2 + numDefine34];
                    r10 = heapClassInst.heapU16[(r8 + numDefine8) >> 1];
                    r9 = (r9 - r7) | 0;
                    heapClassInst.heap16[(r9 + numDefine8) >> 1] = (short) r10;
                    r9 = heapClassInst.heap32[r2 + numDefine34];
                    r10 = heapClassInst.heapU16[(r8 + numDefine10) >> 1];
                    r9 = (r9 - r7) | 0;
                    heapClassInst.heap16[(r9 + numDefine10) >> 1] = (short) r10;
                    r9 = heapClassInst.heap32[r2 + numDefine34];
                    r10 = heapClassInst.heapU16[r8 >> 1];
                    r9 = (r9 - r7) | 0;
                    heapClassInst.heap16[r9 >> 1] = (short) r10;
                    r9 = heapClassInst.heap32[r2 + numDefine34];
                    r10 = heapClassInst.heapU16[(r8 + numDefine2) >> 1];
                    r9 = (r9 - r7) | 0;
                    heapClassInst.heap16[(r9 + numDefine2) >> 1] = (short) r10;
                    r9 = heapClassInst.heap32[r2 + numDefine34];
                    r8 = heapClassInst.heapU16[(r8 + numDefine4) >> 1];
                    r4 = (r4 + -1) | 0;
                    r7 = (r9 - r7) | 0;
                    heapClassInst.heap16[(r7 + numDefine4) >> 1] = (short) r8;
                    if (r5 != r4) {
                        continue repeat35;
                    } else {
                        break repeat33;
                    }
                }
            }
        } while (false);
        r4 = heapClassInst.heap32[r1 + numDefine19];
        heapClassInst.heap32[r2 + numDefine36] = r4;
        r4 = heapClassInst.heap32[r2 + numDefine38];
        r5 = heapClassInst.heap32[r1 + numDefine20];
        if (!(r4 >= r5)) {
            r6 = heapClassInst.heap32[r2 + numDefine39];
            if (!(r6 >= r5)) {
                if (r5 != 0) {
                    r6 = gNumAlignedAllocs;
                    r6 = r6 >> numDefine2;
                    r7 = heapClassInst.heap32[r6];
                    r7 = (r7 + 1) | 0;
                    r8 = r5 << numDefine5;
                    heapClassInst.heap32[r6] = r7;
                    r6 = r8 | numDefine19;
                    heapClassInst.heap32[g0] = r6;
                    mallocNew(i7);
                    r6 = commonVariable.rg0;
                    if (r6 != 0) {
                        r7 = 0;
                        r8 = (r6 + numDefine4) | 0;
                        r7 = (r7 - r8) | 0;
                        r7 = r7 & numDefine15;
                        r7 = (r6 + r7) | 0;
                        r8 = (r7 + numDefine4) | 0;
                        r7 = r7 >> numDefine2;
                        heapClassInst.heap32[r7] = r6;
                        r6 = r8;
                    }
                } else {
                    r6 = 0;
                }
                r7 = (r0 + numDefine160) | 0;
                if (r4 < 1) {
                    r4 = r7 >> numDefine2;
                    r9 = heapClassInst.heap32[r4];
                } else {
                    r8 = 0;
                    repeat49:
                    while (true) {
                        r9 = r7 >> numDefine2;
                        r9 = heapClassInst.heap32[r9];
                        r10 = (r9 + r8) | 0;
                        r10 = r10 >> numDefine2;
                        r11 = (r6 + r8) | 0;
                        r4 = (r4 + -1) | 0;
                        r8 = (r8 + numDefine32) | 0;
                        r12 = heapClassInst.heap32[r10];
                        r11 = r11 >> numDefine2;
                        r13 = heapClassInst.heap32[r10 + 1];
                        r14 = heapClassInst.heap32[r10 + numDefine2];
                        r15 = heapClassInst.heap32[r10 + numDefine3];
                        r16 = heapClassInst.heap32[r10 + numDefine4];
                        r17 = heapClassInst.heap32[r10 + numDefine5];
                        r18 = heapClassInst.heap32[r10 + numDefine6];
                        r10 = heapClassInst.heap32[r10 + numDefine7];
                        heapClassInst.heap32[r11] = r12;
                        heapClassInst.heap32[r11 + 1] = r13;
                        heapClassInst.heap32[r11 + numDefine2] = r14;
                        heapClassInst.heap32[r11 + numDefine3] = r15;
                        heapClassInst.heap32[r11 + numDefine4] = r16;
                        heapClassInst.heap32[r11 + numDefine5] = r17;
                        heapClassInst.heap32[r11 + numDefine6] = r18;
                        heapClassInst.heap32[r11 + numDefine7] = r10;
                        if (!(r4 != 0)) {
                            break repeat49;
                        }
                    }
                    r7 = (r0 + numDefine160) | 0;
                }
                if (!(r9 == 0)) {
                    r4 = heapClassInst.heapU8[r0 + numDefine164];
                    if (!(r4 == 0)) {
                        r4 = gNumAlignedFree;
                        r4 = r4 >> numDefine2;
                        r8 = heapClassInst.heap32[r4];
                        r8 = (r8 + 1) | 0;
                        r9 = r9 >> numDefine2;
                        heapClassInst.heap32[r4] = r8;
                        r4 = heapClassInst.heap32[r9 + -1];
                        heapClassInst.heap32[g0] = r4;
                        free(i7);
                    }
                    r4 = r7 >> numDefine2;
                    heapClassInst.heap32[r4] = 0;
                }
                r4 = 1;
                r7 = r7 >> numDefine2;
                heapClassInst.heap8[r0 + numDefine164] = (byte) r4;
                heapClassInst.heap32[r7] = r6;
                heapClassInst.heap32[r2 + numDefine39] = r5;
            }
        }
        heapClassInst.heap32[r2 + numDefine38] = r5;
        repeat60:
        do {
            if (!(r5 < 1)) {
                r0 = heapClassInst.heap32[r1 + numDefine18];
                r1 = (r3 - r5) | 0;
                repeat62:
                while (true) {
                    r4 = (r3 * numDefineNeg10) | 0;
                    r4 = r4 << 1;
                    r4 = (r0 + r4) | 0;
                    r5 = r3 << numDefine5;
                    r6 = heapClassInst.heap32[r2 + numDefine40];
                    r7 = heapClassInst.heapU16[(r4 + numDefine14) >> 1];
                    r6 = (r6 - r5) | 0;
                    heapClassInst.heap16[(r6 + numDefine6) >> 1] = (short) r7;
                    r6 = heapClassInst.heap32[r2 + numDefine40];
                    r7 = heapClassInst.heapU16[(r4 + numDefine16) >> 1];
                    r6 = (r6 - r5) | 0;
                    heapClassInst.heap16[(r6 + numDefine8) >> 1] = (short) r7;
                    r6 = heapClassInst.heap32[r2 + numDefine40];
                    r7 = heapClassInst.heapU16[(r4 + numDefine18) >> 1];
                    r6 = (r6 - r5) | 0;
                    heapClassInst.heap16[(r6 + numDefine10) >> 1] = (short) r7;
                    r6 = heapClassInst.heap32[r2 + numDefine40];
                    r7 = heapClassInst.heapU16[(r4 + numDefine8) >> 1];
                    r6 = (r6 - r5) | 0;
                    heapClassInst.heap16[r6 >> 1] = (short) r7;
                    r6 = heapClassInst.heap32[r2 + numDefine40];
                    r7 = heapClassInst.heapU16[(r4 + numDefine10) >> 1];
                    r6 = (r6 - r5) | 0;
                    heapClassInst.heap16[(r6 + numDefine2) >> 1] = (short) r7;
                    r6 = (r3 * numDefineNeg5) | 0;
                    r7 = heapClassInst.heap32[r2 + numDefine40];
                    r4 = heapClassInst.heapU16[(r4 + numDefine12) >> 1];
                    r6 = r6 << numDefine2;
                    r7 = (r7 - r5) | 0;
                    r6 = (r0 + r6) | 0;
                    heapClassInst.heap16[(r7 + numDefine4) >> 1] = (short) r4;
                    r4 = r6 >> numDefine2;
                    r6 = heapClassInst.heap32[r2 + numDefine40];
                    r6 = (r6 - r5) | 0;
                    r7 = heapClassInst.heap32[r4];
                    r6 = r6 >> numDefine2;
                    heapClassInst.heap32[r6 + numDefine3] = r7;
                    r6 = heapClassInst.heap32[r2 + numDefine40];
                    r5 = (r6 - r5) | 0;
                    r4 = heapClassInst.heap32[r4 + 1];
                    r3 = (r3 + -1) | 0;
                    r5 = r5 >> numDefine2;
                    heapClassInst.heap32[r5 + numDefine4] = r4;
                    if (r1 != r3) {
                        continue repeat62;
                    } else {
                        break repeat60;
                    }
                }
            }
        } while (false);
        
    }

    public static void zn14btQuantizedBvh17deSerializeDoubleER24btQuantizedBvhDoubleData(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        int r6 = 0;
        int r7 = 0;
        int r8 = 0;
        int r9 = 0;
        int r10 = 0;
        int r11 = 0;
        int r12 = 0;
        int r13 = 0;
        int r14 = 0;
        int r15 = 0;
        int r16 = 0;
        int r17 = 0;
        int r18 = 0;
        double f0 = 0.0F;
        int label = 0;
        i7 = sp + numDefineNeg16;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp + 1];
        r1 = heapClassInst.heap32[fp];
        f0 = llvmReadDouble(r0 + numDefine32);
        r2 = r1 >> numDefine2;
        f0 = f0;
        heapClassInst.heapFloat[r2 + numDefine5] = (float) f0;
        f0 = llvmReadDouble(r0 + numDefine40);
        f0 = f0;
        heapClassInst.heapFloat[r2 + numDefine6] = (float) f0;
        f0 = llvmReadDouble(r0 + numDefine48);
        f0 = f0;
        heapClassInst.heapFloat[r2 + numDefine7] = (float) f0;
        f0 = llvmReadDouble(r0 + numDefine56);
        f0 = f0;
        heapClassInst.heapFloat[r2 + numDefine8] = (float) f0;
        f0 = llvmReadDouble(r0);
        f0 = f0;
        heapClassInst.heapFloat[r2 + 1] = (float) f0;
        f0 = llvmReadDouble(r0 + numDefine8);
        f0 = f0;
        heapClassInst.heapFloat[r2 + numDefine2] = (float) f0;
        f0 = llvmReadDouble(r0 + numDefine16);
        f0 = f0;
        heapClassInst.heapFloat[r2 + numDefine3] = (float) f0;
        f0 = llvmReadDouble(r0 + numDefine24);
        f0 = f0;
        heapClassInst.heapFloat[r2 + numDefine4] = (float) f0;
        f0 = llvmReadDouble(r0 + numDefine64);
        f0 = f0;
        heapClassInst.heapFloat[r2 + numDefine9] = (float) f0;
        f0 = llvmReadDouble(r0 + numDefine72);
        f0 = f0;
        heapClassInst.heapFloat[r2 + numDefine10] = (float) f0;
        f0 = llvmReadDouble(r0 + numDefine80);
        f0 = f0;
        heapClassInst.heapFloat[r2 + numDefine11] = (float) f0;
        f0 = llvmReadDouble(r0 + numDefine88);
        f0 = f0;
        r0 = r0 >> numDefine2;
        heapClassInst.heapFloat[r2 + numDefine12] = (float) f0;
        r3 = heapClassInst.heap32[r0 + numDefine24];
        heapClassInst.heap32[r2 + numDefine14] = r3;
        r3 = 0;
        r4 = heapClassInst.heap32[r0 + numDefine25];
        r4 = r4 != r3 ? 1 : 0;
        r4 = r4 & 1;
        heapClassInst.heap8[r1 + numDefine60] = (byte) r4;
        r4 = heapClassInst.heap32[r2 + numDefine22];
        r5 = heapClassInst.heap32[r0 + numDefine26];
        if (!(r4 >= r5)) {
            r6 = heapClassInst.heap32[r2 + numDefine23];
            if (!(r6 >= r5)) {
                if (r5 != 0) {
                    r6 = gNumAlignedAllocs;
                    r6 = r6 >> numDefine2;
                    r7 = heapClassInst.heap32[r6];
                    r7 = (r7 + 1) | 0;
                    r8 = r5 << numDefine6;
                    heapClassInst.heap32[r6] = r7;
                    r6 = r8 | numDefine19;
                    heapClassInst.heap32[g0] = r6;
                    mallocNew(i7);
                    r6 = commonVariable.rg0;
                    if (r6 != 0) {
                        r7 = 0;
                        r8 = (r6 + numDefine4) | 0;
                        r7 = (r7 - r8) | 0;
                        r7 = r7 & numDefine15;
                        r7 = (r6 + r7) | 0;
                        r8 = (r7 + numDefine4) | 0;
                        r7 = r7 >> numDefine2;
                        heapClassInst.heap32[r7] = r6;
                        r6 = r8;
                    }
                } else {
                    r6 = 0;
                }
                r7 = (r1 + numDefine96) | 0;
                if (r4 < 1) {
                    r4 = r7 >> numDefine2;
                    r9 = heapClassInst.heap32[r4];
                } else {
                    r8 = 0;
                    repeat12:
                    while (true) {
                        r9 = r7 >> numDefine2;
                        r9 = heapClassInst.heap32[r9];
                        r10 = (r6 + r8) | 0;
                        r11 = (r9 + r8) | 0;
                        heapClassInst.heap32[g0] = r10;
                        heapClassInst.heap32[g0 + 1] = r11;
                        heapClassInst.heap32[g0 + numDefine2] = numDefine64;
                        r4 = (r4 + -1) | 0;
                        r8 = (r8 + numDefine64) | 0;
                        memcpy(i7);
                        if (!(r4 != 0)) {
                            break repeat12;
                        }
                    }
                    r7 = (r1 + numDefine96) | 0;
                }
                if (!(r9 == 0)) {
                    r4 = heapClassInst.heapU8[r1 + numDefine100];
                    if (!(r4 == 0)) {
                        r4 = gNumAlignedFree;
                        r4 = r4 >> numDefine2;
                        r8 = heapClassInst.heap32[r4];
                        r8 = (r8 + 1) | 0;
                        r9 = r9 >> numDefine2;
                        heapClassInst.heap32[r4] = r8;
                        r4 = heapClassInst.heap32[r9 + -1];
                        heapClassInst.heap32[g0] = r4;
                        free(i7);
                    }
                    r4 = r7 >> numDefine2;
                    heapClassInst.heap32[r4] = 0;
                }
                r4 = 1;
                r7 = r7 >> numDefine2;
                heapClassInst.heap8[r1 + numDefine100] = (byte) r4;
                heapClassInst.heap32[r7] = r6;
                heapClassInst.heap32[r2 + numDefine23] = r5;
            }
        }
        heapClassInst.heap32[r2 + numDefine22] = r5;
        repeat23:
        do {
            if (!(r5 < 1)) {
                r4 = 0;
                r6 = heapClassInst.heap32[r0 + numDefine28];
                r5 = (r4 - r5) | 0;
                repeat25:
                while (true) {
                    r7 = (r4 * numDefineNeg10) | 0;
                    r7 = r7 << numDefine3;
                    r8 = (r6 + r7) | 0;
                    r9 = r4 << numDefine6;
                    r10 = heapClassInst.heap32[r2 + numDefine24];
                    f0 = llvmReadDouble(r8 + numDefine32);
                    r10 = (r10 - r9) | 0;
                    r10 = r10 >> numDefine2;
                    f0 = f0;
                    heapClassInst.heapFloat[r10 + numDefine4] = (float) f0;
                    f0 = llvmReadDouble(r8 + numDefine40);
                    f0 = f0;
                    heapClassInst.heapFloat[r10 + numDefine5] = (float) f0;
                    f0 = llvmReadDouble(r8 + numDefine48);
                    f0 = f0;
                    heapClassInst.heapFloat[r10 + numDefine6] = (float) f0;
                    f0 = llvmReadDouble(r8 + numDefine56);
                    f0 = f0;
                    heapClassInst.heapFloat[r10 + numDefine7] = (float) f0;
                    r10 = heapClassInst.heap32[r2 + numDefine24];
                    f0 = llvmReadDouble(r6 + r7);
                    r7 = (r10 - r9) | 0;
                    r7 = r7 >> numDefine2;
                    f0 = f0;
                    heapClassInst.heapFloat[r7] = (float) f0;
                    f0 = llvmReadDouble(r8 + numDefine8);
                    f0 = f0;
                    heapClassInst.heapFloat[r7 + 1] = (float) f0;
                    f0 = llvmReadDouble(r8 + numDefine16);
                    f0 = f0;
                    heapClassInst.heapFloat[r7 + numDefine2] = (float) f0;
                    r10 = (r4 * numDefineNeg20) | 0;
                    f0 = llvmReadDouble(r8 + numDefine24);
                    r8 = r10 << numDefine2;
                    f0 = f0;
                    r8 = (r6 + r8) | 0;
                    heapClassInst.heapFloat[r7 + numDefine3] = (float) f0;
                    r7 = r8 >> numDefine2;
                    r8 = heapClassInst.heap32[r2 + numDefine24];
                    r8 = (r8 - r9) | 0;
                    r10 = heapClassInst.heap32[r7 + numDefine16];
                    r8 = r8 >> numDefine2;
                    heapClassInst.heap32[r8 + numDefine8] = r10;
                    r8 = heapClassInst.heap32[r2 + numDefine24];
                    r8 = (r8 - r9) | 0;
                    r10 = heapClassInst.heap32[r7 + numDefine17];
                    r8 = r8 >> numDefine2;
                    heapClassInst.heap32[r8 + numDefine9] = r10;
                    r8 = heapClassInst.heap32[r2 + numDefine24];
                    r8 = (r8 - r9) | 0;
                    r7 = heapClassInst.heap32[r7 + numDefine18];
                    r4 = (r4 + -1) | 0;
                    r8 = r8 >> numDefine2;
                    heapClassInst.heap32[r8 + numDefine10] = r7;
                    if (r5 != r4) {
                        continue repeat25;
                    } else {
                        break repeat23;
                    }
                }
            }
        } while (false);
        r4 = heapClassInst.heap32[r2 + numDefine32];
        r5 = heapClassInst.heap32[r0 + numDefine27];
        repeat28:
        do {
            if (!(r4 >= r5)) {
                r6 = (r1 + numDefine124) | 0;
                heapClassInst.heap32[g0] = r6;
                heapClassInst.heap32[g0 + 1] = r5;
                r6 = (r5 - r4) | 0;
                r4 = r4 << numDefine4;
                zn20btAlignedObjectArrayI18btQuantizedBvhNodeE7reserveEi(i7);
                repeat30:
                while (true) {
                    r7 = heapClassInst.heap32[r2 + numDefine34];
                    r7 = (r7 + r4) | 0;
                    r7 = r7 >> numDefine2;
                    r6 = (r6 + -1) | 0;
                    r4 = (r4 + numDefine16) | 0;
                    heapClassInst.heap32[r7] = 0;
                    heapClassInst.heap32[r7 + 1] = 0;
                    heapClassInst.heap32[r7 + numDefine2] = 0;
                    heapClassInst.heap32[r7 + numDefine3] = 0;
                    if (r6 != 0) {
                        continue repeat30;
                    } else {
                        break repeat28;
                    }
                }
            }
        } while (false);
        heapClassInst.heap32[r2 + numDefine32] = r5;
        repeat33:
        do {
            if (!(r5 < 1)) {
                r4 = 0;
                r6 = heapClassInst.heap32[r0 + numDefine29];
                r5 = (r4 - r5) | 0;
                repeat35:
                while (true) {
                    r7 = r4 << numDefine4;
                    r8 = (r6 - r7) | 0;
                    r9 = r8 >> numDefine2;
                    r10 = heapClassInst.heap32[r2 + numDefine34];
                    r10 = (r10 - r7) | 0;
                    r9 = heapClassInst.heap32[r9 + numDefine3];
                    r10 = r10 >> numDefine2;
                    heapClassInst.heap32[r10 + numDefine3] = r9;
                    r9 = heapClassInst.heap32[r2 + numDefine34];
                    r10 = heapClassInst.heapU16[(r8 + numDefine6) >> 1];
                    r9 = (r9 - r7) | 0;
                    heapClassInst.heap16[(r9 + numDefine6) >> 1] = (short) r10;
                    r9 = heapClassInst.heap32[r2 + numDefine34];
                    r10 = heapClassInst.heapU16[(r8 + numDefine8) >> 1];
                    r9 = (r9 - r7) | 0;
                    heapClassInst.heap16[(r9 + numDefine8) >> 1] = (short) r10;
                    r9 = heapClassInst.heap32[r2 + numDefine34];
                    r10 = heapClassInst.heapU16[(r8 + numDefine10) >> 1];
                    r9 = (r9 - r7) | 0;
                    heapClassInst.heap16[(r9 + numDefine10) >> 1] = (short) r10;
                    r9 = heapClassInst.heap32[r2 + numDefine34];
                    r10 = heapClassInst.heapU16[r8 >> 1];
                    r9 = (r9 - r7) | 0;
                    heapClassInst.heap16[r9 >> 1] = (short) r10;
                    r9 = heapClassInst.heap32[r2 + numDefine34];
                    r10 = heapClassInst.heapU16[(r8 + numDefine2) >> 1];
                    r9 = (r9 - r7) | 0;
                    heapClassInst.heap16[(r9 + numDefine2) >> 1] = (short) r10;
                    r9 = heapClassInst.heap32[r2 + numDefine34];
                    r8 = heapClassInst.heapU16[(r8 + numDefine4) >> 1];
                    r4 = (r4 + -1) | 0;
                    r7 = (r9 - r7) | 0;
                    heapClassInst.heap16[(r7 + numDefine4) >> 1] = (short) r8;
                    if (r5 != r4) {
                        continue repeat35;
                    } else {
                        break repeat33;
                    }
                }
            }
        } while (false);
        r4 = heapClassInst.heap32[r0 + numDefine30];
        heapClassInst.heap32[r2 + numDefine36] = r4;
        r4 = heapClassInst.heap32[r2 + numDefine38];
        r5 = heapClassInst.heap32[r0 + numDefine31];
        if (!(r4 >= r5)) {
            r6 = heapClassInst.heap32[r2 + numDefine39];
            if (!(r6 >= r5)) {
                if (r5 != 0) {
                    r6 = gNumAlignedAllocs;
                    r6 = r6 >> numDefine2;
                    r7 = heapClassInst.heap32[r6];
                    r7 = (r7 + 1) | 0;
                    r8 = r5 << numDefine5;
                    heapClassInst.heap32[r6] = r7;
                    r6 = r8 | numDefine19;
                    heapClassInst.heap32[g0] = r6;
                    mallocNew(i7);
                    r6 = commonVariable.rg0;
                    if (r6 != 0) {
                        r7 = 0;
                        r8 = (r6 + numDefine4) | 0;
                        r7 = (r7 - r8) | 0;
                        r7 = r7 & numDefine15;
                        r7 = (r6 + r7) | 0;
                        r8 = (r7 + numDefine4) | 0;
                        r7 = r7 >> numDefine2;
                        heapClassInst.heap32[r7] = r6;
                        r6 = r8;
                    }
                } else {
                    r6 = 0;
                }
                r7 = (r1 + numDefine160) | 0;
                if (r4 < 1) {
                    r4 = r7 >> numDefine2;
                    r9 = heapClassInst.heap32[r4];
                } else {
                    r8 = 0;
                    repeat49:
                    while (true) {
                        r9 = r7 >> numDefine2;
                        r9 = heapClassInst.heap32[r9];
                        r10 = (r9 + r8) | 0;
                        r10 = r10 >> numDefine2;
                        r11 = (r6 + r8) | 0;
                        r4 = (r4 + -1) | 0;
                        r8 = (r8 + numDefine32) | 0;
                        r12 = heapClassInst.heap32[r10];
                        r11 = r11 >> numDefine2;
                        r13 = heapClassInst.heap32[r10 + 1];
                        r14 = heapClassInst.heap32[r10 + numDefine2];
                        r15 = heapClassInst.heap32[r10 + numDefine3];
                        r16 = heapClassInst.heap32[r10 + numDefine4];
                        r17 = heapClassInst.heap32[r10 + numDefine5];
                        r18 = heapClassInst.heap32[r10 + numDefine6];
                        r10 = heapClassInst.heap32[r10 + numDefine7];
                        heapClassInst.heap32[r11] = r12;
                        heapClassInst.heap32[r11 + 1] = r13;
                        heapClassInst.heap32[r11 + numDefine2] = r14;
                        heapClassInst.heap32[r11 + numDefine3] = r15;
                        heapClassInst.heap32[r11 + numDefine4] = r16;
                        heapClassInst.heap32[r11 + numDefine5] = r17;
                        heapClassInst.heap32[r11 + numDefine6] = r18;
                        heapClassInst.heap32[r11 + numDefine7] = r10;
                        if (!(r4 != 0)) {
                            break repeat49;
                        }
                    }
                    r7 = (r1 + numDefine160) | 0;
                }
                if (!(r9 == 0)) {
                    r4 = heapClassInst.heapU8[r1 + numDefine164];
                    if (!(r4 == 0)) {
                        r4 = gNumAlignedFree;
                        r4 = r4 >> numDefine2;
                        r8 = heapClassInst.heap32[r4];
                        r8 = (r8 + 1) | 0;
                        r9 = r9 >> numDefine2;
                        heapClassInst.heap32[r4] = r8;
                        r4 = heapClassInst.heap32[r9 + -1];
                        heapClassInst.heap32[g0] = r4;
                        free(i7);
                    }
                    r4 = r7 >> numDefine2;
                    heapClassInst.heap32[r4] = 0;
                }
                r4 = 1;
                r7 = r7 >> numDefine2;
                heapClassInst.heap8[r1 + numDefine164] = (byte) r4;
                heapClassInst.heap32[r7] = r6;
                heapClassInst.heap32[r2 + numDefine39] = r5;
            }
        }
        heapClassInst.heap32[r2 + numDefine38] = r5;
        repeat60:
        do {
            if (!(r5 < 1)) {
                r0 = heapClassInst.heap32[r0 + numDefine32];
                r1 = (r3 - r5) | 0;
                repeat62:
                while (true) {
                    r4 = (r3 * numDefineNeg10) | 0;
                    r4 = r4 << 1;
                    r4 = (r0 + r4) | 0;
                    r5 = r3 << numDefine5;
                    r6 = heapClassInst.heap32[r2 + numDefine40];
                    r7 = heapClassInst.heapU16[(r4 + numDefine14) >> 1];
                    r6 = (r6 - r5) | 0;
                    heapClassInst.heap16[(r6 + numDefine6) >> 1] = (short) r7;
                    r6 = heapClassInst.heap32[r2 + numDefine40];
                    r7 = heapClassInst.heapU16[(r4 + numDefine16) >> 1];
                    r6 = (r6 - r5) | 0;
                    heapClassInst.heap16[(r6 + numDefine8) >> 1] = (short) r7;
                    r6 = heapClassInst.heap32[r2 + numDefine40];
                    r7 = heapClassInst.heapU16[(r4 + numDefine18) >> 1];
                    r6 = (r6 - r5) | 0;
                    heapClassInst.heap16[(r6 + numDefine10) >> 1] = (short) r7;
                    r6 = heapClassInst.heap32[r2 + numDefine40];
                    r7 = heapClassInst.heapU16[(r4 + numDefine8) >> 1];
                    r6 = (r6 - r5) | 0;
                    heapClassInst.heap16[r6 >> 1] = (short) r7;
                    r6 = heapClassInst.heap32[r2 + numDefine40];
                    r7 = heapClassInst.heapU16[(r4 + numDefine10) >> 1];
                    r6 = (r6 - r5) | 0;
                    heapClassInst.heap16[(r6 + numDefine2) >> 1] = (short) r7;
                    r6 = (r3 * numDefineNeg5) | 0;
                    r7 = heapClassInst.heap32[r2 + numDefine40];
                    r4 = heapClassInst.heapU16[(r4 + numDefine12) >> 1];
                    r6 = r6 << numDefine2;
                    r7 = (r7 - r5) | 0;
                    r6 = (r0 + r6) | 0;
                    heapClassInst.heap16[(r7 + numDefine4) >> 1] = (short) r4;
                    r4 = r6 >> numDefine2;
                    r6 = heapClassInst.heap32[r2 + numDefine40];
                    r6 = (r6 - r5) | 0;
                    r7 = heapClassInst.heap32[r4];
                    r6 = r6 >> numDefine2;
                    heapClassInst.heap32[r6 + numDefine3] = r7;
                    r6 = heapClassInst.heap32[r2 + numDefine40];
                    r5 = (r6 - r5) | 0;
                    r4 = heapClassInst.heap32[r4 + 1];
                    r3 = (r3 + -1) | 0;
                    r5 = r5 >> numDefine2;
                    heapClassInst.heap32[r5 + numDefine4] = r4;
                    if (r1 != r3) {
                        continue repeat62;
                    } else {
                        break repeat60;
                    }
                }
            }
        } while (false);
        
    }

    public static void znk14btQuantizedBvh36walkStacklessQuantizedTreeAgainstRayEP21btNodeOverlapCallbackRK9btVector3S4S4S4Ii(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        int r6 = 0;
        int r7 = 0;
        int r8 = 0;
        int r9 = 0;
        int r10 = 0;
        int r11 = 0;
        int r12 = 0;
        int r13 = 0;
        int r14 = 0;
        int r15 = 0;
        int r16 = 0;
        int r17 = 0;
        int r18 = 0;
        int r19 = 0;
        int r20 = 0;
        int r21 = 0;
        float f0 = 0.0F;
        float f1 = 0.0F;
        float f2 = 0.0F;
        float f3 = 0.0F;
        float f4 = 0.0F;
        float f5 = 0.0F;
        float f6 = 0.0F;
        float f7 = 0.0F;
        float f8 = 0.0F;
        float f9 = 0.0F;
        float f10 = 0.0F;
        float f11 = 0.0F;
        float f12 = 0.0F;
        float f13 = 0.0F;
        float f14 = 0.0F;
        float f15 = 0.0F;
        float f16 = 0.0F;
        float f17 = 0.0F;
        float f18 = 0.0F;
        float f19 = 0.0F;
        int label = 0;
        i7 = sp + numDefineNeg96;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = heapClassInst.heapU8[r0 + numDefine60];
        if (r1 != 0) {
            r1 = heapClassInst.heap32[fp + 1];
            r2 = heapClassInst.heap32[fp + numDefine2];
            r3 = heapClassInst.heap32[fp + numDefine3];
            r4 = heapClassInst.heap32[fp + numDefine4];
            r5 = heapClassInst.heap32[fp + numDefine5];
            r6 = heapClassInst.heap32[fp + numDefine6];
            r3 = r3 >> numDefine2;
            r2 = r2 >> numDefine2;
            f0 = heapClassInst.heapFloat[r3];
            f1 = heapClassInst.heapFloat[r2];
            f2 = heapClassInst.heapFloat[r3 + 1];
            f3 = heapClassInst.heapFloat[r2 + 1];
            f0 = f0 - f1;
            r7 = r0 >> numDefine2;
            f1 = f2 - f3;
            f2 = heapClassInst.heapFloat[r3 + numDefine2];
            f3 = heapClassInst.heapFloat[r2 + numDefine2];
            r8 = heapClassInst.heap32[r7 + numDefine34];
            f2 = f2 - f3;
            f3 = f0 * f0;
            f4 = f1 * f1;
            f3 = f3 + f4;
            f4 = f2 * f2;
            f3 = f3 + f4;
            heapClassInst.heapFloat[g0] = f3;
            sqrtf(i7);
            f4 = 1;
            f3 = (float) (f4 / commonVariable.fg0);
            f5 = heapClassInst.heapFloat[r3];
            f6 = heapClassInst.heapFloat[r2];
            f7 = heapClassInst.heapFloat[r3 + 1];
            f8 = heapClassInst.heapFloat[r2 + 1];
            f0 = f0 * f3;
            f9 = f5 - f6;
            f1 = f1 * f3;
            f10 = f7 - f8;
            f11 = heapClassInst.heapFloat[r3 + numDefine2];
            f12 = heapClassInst.heapFloat[r2 + numDefine2];
            f2 = f2 * f3;
            f3 = f11 - f12;
            f9 = f0 * f9;
            f10 = f1 * f10;
            f9 = f9 + f10;
            f3 = f2 * f3;
            f3 = f9 + f3;
            f9 = 0;
            if (f0 != f9) {
                f0 = f4 / f0;
            } else {
                f0 = numDefine49440;
            }
            if (f1 != f9) {
                f1 = f4 / f1;
            } else {
                f1 = numDefine49440;
            }
            if (f2 != f9) {
                f2 = f4 / f2;
            } else {
                f2 = numDefine49440;
            }
            r9 = heapClassInst.heapU8[r0 + numDefine60];
            if (r9 != 0) {
                r4 = r4 >> numDefine2;
                r5 = r5 >> numDefine2;

                r9 = f0 < f9 ? 1 : 0;
                r10 = f1 < f9 ? 1 : 0;
                r11 = f2 < f9 ? 1 : 0;

                f4 = heapClassInst.heapFloat[r2 + numDefine3];
                f10 = heapClassInst.heapFloat[r3 + numDefine3];
                f13 = f5 < f6 ? f5 : f6;
                f14 = heapClassInst.heapFloat[r4];
                f15 = f7 < f8 ? f7 : f8;
                f16 = heapClassInst.heapFloat[r4 + 1];
                f17 = f11 < f12 ? f11 : f12;
                f18 = heapClassInst.heapFloat[r4 + numDefine2];
                f5 = f6 < f5 ? f5 : f6;
                f6 = heapClassInst.heapFloat[r5];
                f7 = f8 < f7 ? f7 : f8;
                f8 = heapClassInst.heapFloat[r5 + 1];
                f11 = f12 < f11 ? f11 : f12;
                f12 = heapClassInst.heapFloat[r5 + numDefine2];
                r3 = r9 & 1;
                r9 = r10 & 1;
                r10 = r11 & 1;
                f19 = f10 < f4 ? f10 : f4;
                f4 = f4 < f10 ? f10 : f4;
                f10 = f13 + f14;
                f13 = f15 + f16;
                f14 = f17 + f18;
                f5 = f5 + f6;
                f6 = f7 + f8;
                f7 = f11 + f12;
                r11 = sp + numDefineNeg16;
                r12 = r11 >> numDefine2;
                heapClassInst.heapFloat[fp + numDefineNeg4] = f10;
                heapClassInst.heapFloat[r12 + 1] = f13;
                heapClassInst.heapFloat[r12 + numDefine2] = f14;
                heapClassInst.heapFloat[r12 + numDefine3] = f19;
                f8 = heapClassInst.heapFloat[r7 + 1];
                if (f10 < f8) {
                    heapClassInst.heapFloat[fp + numDefineNeg4] = f8;
                    f10 = f8;
                }
                f8 = heapClassInst.heapFloat[r7 + numDefine2];
                if (f13 < f8) {
                    heapClassInst.heapFloat[r12 + 1] = f8;
                    f13 = f8;
                }
                f8 = heapClassInst.heapFloat[r7 + numDefine3];
                if (f14 < f8) {
                    heapClassInst.heapFloat[r12 + numDefine2] = f8;
                    f14 = f8;
                }
                f8 = heapClassInst.heapFloat[r7 + numDefine4];
                if (f19 < f8) {
                    heapClassInst.heapFloat[r12 + numDefine3] = f8;
                    f19 = f8;
                }
                f8 = heapClassInst.heapFloat[r7 + numDefine5];
                if (!(f8 >= f10)) {
                    heapClassInst.heapFloat[fp + numDefineNeg4] = f8;
                }
                f8 = heapClassInst.heapFloat[r7 + numDefine6];
                if (!(f8 >= f13)) {
                    heapClassInst.heapFloat[r12 + 1] = f8;
                }
                f8 = heapClassInst.heapFloat[r7 + numDefine7];
                if (!(f8 >= f14)) {
                    heapClassInst.heapFloat[r12 + numDefine2] = f8;
                }
                f8 = heapClassInst.heapFloat[r7 + numDefine8];
                if (!(f8 >= f19)) {
                    heapClassInst.heapFloat[r12 + numDefine3] = f8;
                }
                r12 = sp + numDefineNeg38;
                heapClassInst.heap32[g0] = r0;
                heapClassInst.heap32[g0 + 1] = r12;
                heapClassInst.heap32[g0 + numDefine2] = r11;
                heapClassInst.heap32[g0 + numDefine3] = 0;
                znk14btQuantizedBvh8quantizeEPtRK9btVector3i(i7);
                r11 = heapClassInst.heapU8[r0 + numDefine60];
                if (r11 != 0) {
                    r11 = sp + numDefineNeg32;
                    r12 = r11 >> numDefine2;
                    heapClassInst.heapFloat[fp + numDefineNeg8] = f5;
                    heapClassInst.heapFloat[r12 + 1] = f6;
                    heapClassInst.heapFloat[r12 + numDefine2] = f7;
                    heapClassInst.heapFloat[r12 + numDefine3] = f4;
                    f8 = heapClassInst.heapFloat[r7 + 1];
                    if (f5 < f8) {
                        heapClassInst.heapFloat[fp + numDefineNeg8] = f8;
                        f5 = f8;
                    }
                    f8 = heapClassInst.heapFloat[r7 + numDefine2];
                    if (f6 < f8) {
                        heapClassInst.heapFloat[r12 + 1] = f8;
                        f6 = f8;
                    }
                    f8 = heapClassInst.heapFloat[r7 + numDefine3];
                    if (f7 < f8) {
                        heapClassInst.heapFloat[r12 + numDefine2] = f8;
                        f7 = f8;
                    }
                    f8 = heapClassInst.heapFloat[r7 + numDefine4];
                    if (f4 < f8) {
                        heapClassInst.heapFloat[r12 + numDefine3] = f8;
                        f4 = f8;
                    }
                    f8 = heapClassInst.heapFloat[r7 + numDefine5];
                    if (!(f8 >= f5)) {
                        heapClassInst.heapFloat[fp + numDefineNeg8] = f8;
                    }
                    f5 = heapClassInst.heapFloat[r7 + numDefine6];
                    if (!(f5 >= f6)) {
                        heapClassInst.heapFloat[r12 + 1] = f5;
                    }
                    f5 = heapClassInst.heapFloat[r7 + numDefine7];
                    if (!(f5 >= f7)) {
                        heapClassInst.heapFloat[r12 + numDefine2] = f5;
                    }
                    f5 = heapClassInst.heapFloat[r7 + numDefine8];
                    if (!(f5 >= f4)) {
                        heapClassInst.heapFloat[r12 + numDefine3] = f5;
                    }
                    r12 = sp + numDefineNeg44;
                    heapClassInst.heap32[g0] = r0;
                    heapClassInst.heap32[g0 + 1] = r12;
                    heapClassInst.heap32[g0 + numDefine2] = r11;
                    heapClassInst.heap32[g0 + numDefine3] = 1;
                    r0 = r3 ^ 1;
                    r11 = r9 ^ 1;
                    r12 = r10 ^ 1;
                    r13 = 0;
                    znk14btQuantizedBvh8quantizeEPtRK9btVector3i(i7);
                    r14 = r13;
                    repeat66:
                    while (true) {
                        if (r13 < r6) {
                            if (r14 < r6) {
                                r15 = r8 >> numDefine2;
                                r16 = heapClassInst.heap32[r15 + numDefine3];
                                r14 = (r14 + 1) | 0;
                                r16 = r16 >>> numDefine31;
                                r17 = heapClassInst.heapU16[(sp + numDefineNeg38) >> 1];
                                r18 = heapClassInst.heapU16[(r8 + numDefine6) >> 1];
                                if (uint(r17) > uint(r18)) {
                                    label = numDefine55;
                                } else {
                                    r17 = heapClassInst.heapU16[r8 >> 1];
                                    r18 = heapClassInst.heapU16[(sp + numDefineNeg44) >> 1];
                                    r18 = r18 & numDefine65535;
                                    r17 = r17 & numDefine65535;
                                    if (uint(r18) < uint(r17)) {
                                        label = numDefine55;
                                    } else {
                                        r18 = heapClassInst.heapU16[(sp + numDefineNeg34) >> 1];
                                        r19 = heapClassInst.heapU16[(r8 + numDefine10) >> 1];
                                        r18 = r18 & numDefine65535;
                                        r19 = r19 & numDefine65535;
                                        if (uint(r18) > uint(r19)) {
                                            label = numDefine55;
                                        } else {
                                            r18 = heapClassInst.heapU16[(r8 + numDefine4) >> 1];
                                            r19 = heapClassInst.heapU16[(sp + numDefineNeg40) >> 1];
                                            r19 = r19 & numDefine65535;
                                            r18 = r18 & numDefine65535;
                                            if (uint(r19) < uint(r18)) {
                                                label = numDefine55;
                                            } else {
                                                r19 = heapClassInst.heapU16[(sp + numDefineNeg36) >> 1];
                                                r20 = heapClassInst.heapU16[(r8 + numDefine8) >> 1];
                                                r19 = r19 & numDefine65535;
                                                r20 = r20 & numDefine65535;
                                                if (uint(r19) > uint(r20)) {
                                                    label = numDefine55;
                                                } else {
                                                    r19 = heapClassInst.heapU16[(r8 + numDefine2) >> 1];
                                                    r20 = heapClassInst.heapU16[(sp + numDefineNeg42) >> 1];
                                                    r20 = r20 & numDefine65535;
                                                    r19 = r19 & numDefine65535;
                                                    if (uint(r20) >= uint(r19)) {
                                                        f4 = uint(r17);
                                                        f5 = heapClassInst.heapFloat[r7 + numDefine9];
                                                        f6 = uint(r19);
                                                        f7 = heapClassInst.heapFloat[r7 + numDefine10];
                                                        f4 = f4 / f5;
                                                        f8 = heapClassInst.heapFloat[r7 + 1];
                                                        f10 = heapClassInst.heapFloat[r7 + numDefine11];
                                                        f11 = heapClassInst.heapFloat[r7 + numDefine2];
                                                        f12 = heapClassInst.heapFloat[r7 + numDefine3];
                                                        r17 = sp + numDefineNeg80;
                                                        f13 = uint(r18);
                                                        f6 = f6 / f7;
                                                        f4 = f4 + f8;
                                                        f13 = f13 / f10;
                                                        r18 = r17 >> numDefine2;
                                                        f6 = f6 + f11;
                                                        heapClassInst.heapFloat[fp + numDefineNeg20] = f4;
                                                        f13 = f13 + f12;
                                                        heapClassInst.heapFloat[r18 + 1] = f6;
                                                        heapClassInst.heapFloat[r18 + numDefine2] = f13;
                                                        heapClassInst.heap32[r18 + numDefine3] = 0;
                                                        r19 = heapClassInst.heapU16[(r8 + numDefine10) >> 1];
                                                        r20 = heapClassInst.heapU16[(r8 + numDefine8) >> 1];
                                                        r21 = heapClassInst.heapU16[(r8 + numDefine6) >> 1];
                                                        heapClassInst.heap32[r18 + numDefine7] = 0;
                                                        f14 = heapClassInst.heapFloat[r5];
                                                        f4 = f4 - f14;
                                                        heapClassInst.heapFloat[fp + numDefineNeg20] = f4;
                                                        f4 = heapClassInst.heapFloat[r5 + 1];
                                                        f4 = f6 - f4;
                                                        heapClassInst.heapFloat[r18 + 1] = f4;
                                                        f4 = heapClassInst.heapFloat[r5 + numDefine2];
                                                        f6 = uint(r21);
                                                        f4 = f13 - f4;
                                                        f5 = f6 / f5;
                                                        heapClassInst.heapFloat[r18 + numDefine2] = f4;
                                                        f4 = f5 + f8;
                                                        f5 = heapClassInst.heapFloat[r4];
                                                        f6 = uint(r20);
                                                        f4 = f4 - f5;
                                                        f5 = f6 / f7;
                                                        heapClassInst.heapFloat[r18 + numDefine4] = f4;
                                                        f4 = f5 + f11;
                                                        f5 = heapClassInst.heapFloat[r4 + 1];
                                                        f6 = uint(r19);
                                                        f4 = f4 - f5;
                                                        f5 = f6 / f10;
                                                        heapClassInst.heapFloat[r18 + numDefine5] = f4;
                                                        r19 = r3 << numDefine4;
                                                        r20 = r11 << numDefine4;
                                                        f4 = f5 + f12;
                                                        f5 = heapClassInst.heapFloat[r4 + numDefine2];
                                                        r19 = (r17 + r19) | 0;
                                                        r20 = (r17 + r20) | 0;
                                                        f4 = f4 - f5;
                                                        r19 = r19 >> numDefine2;
                                                        heapClassInst.heapFloat[r18 + numDefine6] = f4;
                                                        r18 = r20 >> numDefine2;
                                                        f4 = heapClassInst.heapFloat[r19];
                                                        f5 = heapClassInst.heapFloat[r2];
                                                        f6 = heapClassInst.heapFloat[r18 + 1];
                                                        f7 = heapClassInst.heapFloat[r2 + 1];
                                                        f4 = f4 - f5;
                                                        f6 = f6 - f7;
                                                        f4 = f4 * f0;
                                                        f6 = f6 * f1;
                                                        if (f4 > f6) {
                                                            label = numDefine55;
                                                        } else {
                                                            r18 = r0 << numDefine4;
                                                            r19 = r9 << numDefine4;
                                                            r18 = (r17 + r18) | 0;
                                                            r19 = (r17 + r19) | 0;
                                                            r18 = r18 >> numDefine2;
                                                            r19 = r19 >> numDefine2;
                                                            f8 = heapClassInst.heapFloat[r18];
                                                            f10 = heapClassInst.heapFloat[r19 + 1];
                                                            f5 = f8 - f5;
                                                            f7 = f10 - f7;
                                                            f5 = f5 * f0;
                                                            f7 = f7 * f1;
                                                            if (f7 > f5) {
                                                                label = numDefine55;
                                                            } else {
                                                                r18 = r12 << numDefine4;
                                                                r18 = (r17 + r18) | 0;
                                                                r18 = r18 >> numDefine2;
                                                                f8 = heapClassInst.heapFloat[r18 + numDefine2];
                                                                f10 = heapClassInst.heapFloat[r2 + numDefine2];
                                                                f8 = f8 - f10;
                                                                f4 = f4 < f7 ? f7 : f4;
                                                                f7 = f8 * f2;
                                                                if (f4 > f7) {
                                                                    label = numDefine55;
                                                                } else {
                                                                    r18 = r10 << numDefine4;
                                                                    r17 = (r17 + r18) | 0;
                                                                    r17 = r17 >> numDefine2;
                                                                    f8 = heapClassInst.heapFloat[r17 + numDefine2];
                                                                    f8 = f8 - f10;
                                                                    f5 = f6 < f5 ? f6 : f5;
                                                                    f6 = f8 * f2;
                                                                    if (f6 > f5) {
                                                                        label = numDefine55;
                                                                    } else {
                                                                        f4 = f4 < f6 ? f6 : f4;
                                                                        f5 = f7 < f5 ? f7 : f5;

                                                                        r17 = f4 >= f3 ? 1 : 0;
                                                                        r18 = f5 <= f9 ? 1 : 0;

                                                                        r17 = r17 | r18;
                                                                        r18 = r17 & 1;
                                                                        r17 = r18 ^ 1;
                                                                        if (r16 != 0) {
                                                                            label = numDefine65;
                                                                        } else {
                                                                            if (r18 == 0) {
                                                                                r18 = heapClassInst.heap32[r15 + numDefine3];
                                                                                if (r18 > -1) {
                                                                                    r19 = r1 >> numDefine2;
                                                                                    r19 = heapClassInst.heap32[r19];
                                                                                    r19 = r19 >> numDefine2;
                                                                                    r19 = heapClassInst.heap32[r19 + numDefine2];
                                                                                    r20 = r18 >> numDefine21;
                                                                                    r18 = (int) (r18 & numDefine97151);
                                                                                    heapClassInst.heap32[g0] = r1;
                                                                                    heapClassInst.heap32[g0 + 1] = r20;
                                                                                    heapClassInst.heap32[g0 + numDefine2] = r18;
                                                                                    functionTable.get(r19 >> numDefine2).accept(i7);
                                                                                    label = numDefine65;
                                                                                } else {
                                                                                    label = numDefine63;
                                                                                    break repeat66;
                                                                                }
                                                                            } else {
                                                                                label = numDefine65;
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    } else {
                                                        label = numDefine55;
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                                if (label == numDefine55) {
                                    r17 = 0;
                                }
                                if (!(r17 != 0)) {
                                    if (r16 != 0) {
                                        r15 = heapClassInst.heap32[r15 + numDefine3];
                                        if (r15 < 0) {
                                            r16 = r15 << numDefine4;
                                            r8 = (r8 - r16) | 0;
                                            r13 = (r13 - r15) | 0;
                                            continue repeat66;
                                        } else {
                                            label = numDefine69;
                                            break repeat66;
                                        }
                                    }
                                }
                                r8 = (r8 + numDefine16) | 0;
                                r13 = (r13 + 1) | 0;
                            } else {
                                label = numDefine48;
                                break repeat66;
                            }
                        } else {
                            label = numDefine72;
                            break repeat66;
                        }
                    }
                    switch (label) {
                        case numDefine72:
                            r0 = maxIterations;
                            r0 = r0 >> numDefine2;
                            r1 = heapClassInst.heap32[r0];
                            if (!(r1 >= r14)) {
                                heapClassInst.heap32[r0] = r14;
                            }
                            return;
                        case numDefine69:
                            r0 = twoEStr941;
                            r1 = twoEStr313;
                            heapClassInst.heap32[g0] = r0;
                            heapClassInst.heap32[g0 + 1] = r1;
                            heapClassInst.heap32[g0 + numDefine2] = numDefine75;
                            assertNew(i7);
                            break;
                        case numDefine63:
                            r0 = twoEStr739;
                            r1 = twoEStr313;
                            heapClassInst.heap32[g0] = r0;
                            heapClassInst.heap32[g0 + 1] = r1;
                            heapClassInst.heap32[g0 + numDefine2] = numDefine80;
                            assertNew(i7);
                            break;
                        case numDefine48:
                            r0 = twoEStr1143;
                            r1 = twoEStr537;
                            heapClassInst.heap32[g0] = r0;
                            heapClassInst.heap32[g0 + 1] = r1;
                            heapClassInst.heap32[g0 + numDefine2] = numDefine606;
                            assertNew(i7);
                            break;
                        default:
                            break;
                    }
                }
            }
            r0 = twoEStr212;
            r1 = twoEStr313;
            heapClassInst.heap32[g0] = r0;
            heapClassInst.heap32[g0 + 1] = r1;
            heapClassInst.heap32[g0 + numDefine2] = numDefine420;
            assertNew(i7);
        } else {
            r0 = twoEStr212;
            r1 = twoEStr537;
            heapClassInst.heap32[g0] = r0;
            heapClassInst.heap32[g0 + 1] = r1;
            heapClassInst.heap32[g0 + numDefine2] = numDefine543;
            assertNew(i7);
        }
    }

    public static void znk14btQuantizedBvh27walkStacklessTreeAgainstRayEP21btNodeOverlapCallbackRK9btVector3S4S4S4Ii(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        int r6 = 0;
        int r7 = 0;
        int r8 = 0;
        int r9 = 0;
        int r10 = 0;
        int r11 = 0;
        int r12 = 0;
        int r13 = 0;
        int r14 = 0;
        int r15 = 0;
        int r16 = 0;
        int r17 = 0;
        int r18 = 0;
        int r19 = 0;
        float f0 = 0.0F;
        float f1 = 0.0F;
        float f2 = 0.0F;
        float f3 = 0.0F;
        float f4 = 0.0F;
        float f5 = 0.0F;
        float f6 = 0.0F;
        float f7 = 0.0F;
        float f8 = 0.0F;
        float f9 = 0.0F;
        float f10 = 0.0F;
        float f11 = 0.0F;
        float f12 = 0.0F;
        float f13 = 0.0F;
        float f14 = 0.0F;
        float f15 = 0.0F;
        float f16 = 0.0F;
        float f17 = 0.0F;
        float f18 = 0.0F;
        float f19 = 0.0F;
        float f20 = 0.0F;
        float f21 = 0.0F;
        int label = 0;
        i7 = sp + numDefineNeg48;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = heapClassInst.heapU8[r0 + numDefine60];
        if (r1 == 0) {
            r1 = heapClassInst.heap32[fp + 1];
            r2 = heapClassInst.heap32[fp + numDefine2];
            r3 = heapClassInst.heap32[fp + numDefine3];
            r4 = heapClassInst.heap32[fp + numDefine4];
            r5 = heapClassInst.heap32[fp + numDefine5];
            r3 = r3 >> numDefine2;
            r2 = r2 >> numDefine2;
            f0 = heapClassInst.heapFloat[r2];
            f1 = heapClassInst.heapFloat[r3];
            f2 = heapClassInst.heapFloat[r3 + 1];
            f3 = heapClassInst.heapFloat[r2 + 1];
            r4 = r4 >> numDefine2;
            r5 = r5 >> numDefine2;
            f4 = f1 - f0;
            r0 = r0 >> numDefine2;
            f5 = f2 - f3;
            f6 = heapClassInst.heapFloat[r3 + numDefine2];
            f7 = heapClassInst.heapFloat[r2 + numDefine2];
            r6 = heapClassInst.heap32[r0 + numDefine24];
            f8 = f6 - f7;
            f9 = f4 * f4;
            f10 = f5 * f5;
            f11 = heapClassInst.heapFloat[r4];
            f12 = heapClassInst.heapFloat[r4 + 1];
            f13 = heapClassInst.heapFloat[r4 + numDefine2];
            f14 = heapClassInst.heapFloat[r5];
            f15 = heapClassInst.heapFloat[r5 + 1];
            f16 = heapClassInst.heapFloat[r5 + numDefine2];
            f9 = f9 + f10;
            f10 = f8 * f8;
            f9 = f9 + f10;
            heapClassInst.heapFloat[g0] = f9;
            sqrtf(i7);
            f10 = 1;
            f9 = (float) (f10 / commonVariable.fg0);
            f17 = heapClassInst.heapFloat[r3];
            f18 = heapClassInst.heapFloat[r2];
            f19 = heapClassInst.heapFloat[r3 + 1];
            f20 = heapClassInst.heapFloat[r2 + 1];
            f4 = f4 * f9;
            f17 = f17 - f18;
            f5 = f5 * f9;
            f18 = f19 - f20;
            f19 = heapClassInst.heapFloat[r3 + numDefine2];
            f20 = heapClassInst.heapFloat[r2 + numDefine2];
            f8 = f8 * f9;
            f9 = f19 - f20;
            f17 = f4 * f17;
            f18 = f5 * f18;
            f19 = f1 < f0 ? f1 : f0;
            f20 = f2 < f3 ? f2 : f3;
            f21 = f6 < f7 ? f6 : f7;
            f0 = f0 < f1 ? f1 : f0;
            f1 = f3 < f2 ? f2 : f3;
            f2 = f7 < f6 ? f6 : f7;
            f3 = f17 + f18;
            f6 = f8 * f9;
            f7 = f19 + f11;
            f9 = f20 + f12;
            f11 = f21 + f13;
            f0 = f0 + f14;
            f1 = f1 + f15;
            f2 = f2 + f16;
            f3 = f3 + f6;
            f6 = 0;
            if (f4 != f6) {
                f4 = f10 / f4;
            } else {
                f4 = numDefine49440;
            }
            if (f5 != f6) {
                f5 = f10 / f5;
            } else {
                f5 = numDefine49440;
            }
            if (f8 != f6) {
                f8 = f10 / f8;
            } else {
                f8 = numDefine49440;
            }

            r3 = f4 < f6 ? 1 : 0;
            r7 = f5 < f6 ? 1 : 0;
            r8 = f8 < f6 ? 1 : 0;

            r3 = r3 & 1;
            r7 = r7 & 1;
            r8 = r8 & 1;
            r9 = r3 ^ 1;
            r10 = r7 ^ 1;
            r11 = r8 ^ 1;
            r12 = 0;
            r13 = r12;
            repeat15:
            while (true) {
                r14 = heapClassInst.heap32[r0 + numDefine14];
                if (r14 > r12) {
                    if (r14 > r13) {
                        r14 = r6 >> numDefine2;
                        f10 = heapClassInst.heapFloat[r14];
                        r15 = sp + numDefineNeg32;
                        heapClassInst.heapFloat[fp + numDefineNeg8] = f10;
                        r16 = r15 >> numDefine2;
                        f12 = heapClassInst.heapFloat[r14 + 1];
                        heapClassInst.heapFloat[r16 + 1] = f12;
                        f13 = heapClassInst.heapFloat[r14 + numDefine2];
                        heapClassInst.heapFloat[r16 + numDefine2] = f13;
                        heapClassInst.heap32[r16 + numDefine3] = heapClassInst.heap32[r14 + numDefine3];
                        f14 = heapClassInst.heapFloat[r14 + numDefine4];
                        heapClassInst.heapFloat[r16 + numDefine4] = f14;
                        f15 = heapClassInst.heapFloat[r14 + numDefine5];
                        heapClassInst.heapFloat[r16 + numDefine5] = f15;
                        f16 = heapClassInst.heapFloat[r14 + numDefine6];
                        heapClassInst.heapFloat[r16 + numDefine6] = f16;
                        heapClassInst.heap32[r16 + numDefine7] = heapClassInst.heap32[r14 + numDefine7];
                        f17 = heapClassInst.heapFloat[r5];
                        f10 = f10 - f17;
                        heapClassInst.heapFloat[fp + numDefineNeg8] = f10;
                        f10 = heapClassInst.heapFloat[r5 + 1];
                        f10 = f12 - f10;
                        heapClassInst.heapFloat[r16 + 1] = f10;
                        f10 = heapClassInst.heapFloat[r5 + numDefine2];
                        f10 = f13 - f10;
                        heapClassInst.heapFloat[r16 + numDefine2] = f10;
                        f10 = heapClassInst.heapFloat[r4];
                        f10 = f14 - f10;
                        heapClassInst.heapFloat[r16 + numDefine4] = f10;
                        f10 = heapClassInst.heapFloat[r4 + 1];
                        f10 = f15 - f10;
                        heapClassInst.heapFloat[r16 + numDefine5] = f10;
                        f10 = heapClassInst.heapFloat[r4 + numDefine2];
                        r13 = (r13 + 1) | 0;
                        f10 = f16 - f10;
                        heapClassInst.heapFloat[r16 + numDefine6] = f10;
                        f10 = heapClassInst.heapFloat[r14 + numDefine4];
                        if (f7 > f10) {
                            label = numDefine17;
                        } else {
                            f10 = heapClassInst.heapFloat[r14];
                            if (f0 < f10) {
                                label = numDefine17;
                            } else {
                                r16 = 1;
                                label = numDefine18;
                            }
                        }
                        if (label == numDefine17) {
                            r16 = 0;
                        }
                        f10 = heapClassInst.heapFloat[r14 + numDefine6];
                        if (f11 > f10) {
                            label = numDefine20;
                        } else {
                            f10 = heapClassInst.heapFloat[r14 + numDefine2];
                            if (f2 < f10) {
                                label = numDefine20;
                            } else {
                                label = numDefine21;
                            }
                        }
                        if (label == numDefine20) {
                            r16 = 0;
                        }
                        f10 = heapClassInst.heapFloat[r14 + numDefine5];
                        if (f9 > f10) {
                            label = numDefine30;
                        } else {
                            f10 = heapClassInst.heapFloat[r14 + 1];
                            if (f1 < f10) {
                                label = numDefine30;
                            } else {
                                r16 = r16 & numDefine255;
                                if (r16 == 0) {
                                    label = numDefine30;
                                } else {
                                    r16 = r3 << numDefine4;
                                    r17 = r10 << numDefine4;
                                    r16 = (r15 + r16) | 0;
                                    r17 = (r15 + r17) | 0;
                                    r16 = r16 >> numDefine2;
                                    r17 = r17 >> numDefine2;
                                    f10 = heapClassInst.heapFloat[r16];
                                    f12 = heapClassInst.heapFloat[r2];
                                    f13 = heapClassInst.heapFloat[r17 + 1];
                                    f14 = heapClassInst.heapFloat[r2 + 1];
                                    f10 = f10 - f12;
                                    f13 = f13 - f14;
                                    f10 = f10 * f4;
                                    f13 = f13 * f5;
                                    if (f10 > f13) {
                                        label = numDefine30;
                                    } else {
                                        r16 = r9 << numDefine4;
                                        r17 = r7 << numDefine4;
                                        r16 = (r15 + r16) | 0;
                                        r17 = (r15 + r17) | 0;
                                        r16 = r16 >> numDefine2;
                                        r17 = r17 >> numDefine2;
                                        f15 = heapClassInst.heapFloat[r16];
                                        f16 = heapClassInst.heapFloat[r17 + 1];
                                        f12 = f15 - f12;
                                        f14 = f16 - f14;
                                        f12 = f12 * f4;
                                        f14 = f14 * f5;
                                        if (f14 > f12) {
                                            label = numDefine30;
                                        } else {
                                            r16 = r11 << numDefine4;
                                            r16 = (r15 + r16) | 0;
                                            r16 = r16 >> numDefine2;
                                            f15 = heapClassInst.heapFloat[r16 + numDefine2];
                                            f16 = heapClassInst.heapFloat[r2 + numDefine2];
                                            f15 = f15 - f16;
                                            f10 = f10 < f14 ? f14 : f10;
                                            f14 = f15 * f8;
                                            if (f10 > f14) {
                                                label = numDefine30;
                                            } else {
                                                r16 = r8 << numDefine4;
                                                r15 = (r15 + r16) | 0;
                                                r15 = r15 >> numDefine2;
                                                f15 = heapClassInst.heapFloat[r15 + numDefine2];
                                                f15 = f15 - f16;
                                                f12 = f13 < f12 ? f13 : f12;
                                                f13 = f15 * f8;
                                                if (f13 > f12) {
                                                    label = numDefine30;
                                                } else {
                                                    f10 = f10 < f13 ? f13 : f10;
                                                    f12 = f14 < f12 ? f14 : f12;
                                                    r15 = f10 >= f3 ? 1 : 0;
                                                    r16 = f12 <= f6 ? 1 : 0;
                                                    r15 = r15 | r16;
                                                    r16 = r15 & 1;
                                                    r17 = heapClassInst.heap32[r14 + numDefine8];
                                                    r18 = -1;
                                                    r16 = r16 ^ 1;
                                                    r19 = r17 == r18 ? 1 : 0;
                                                    if (r15 != 0) {
                                                        label = numDefine32;
                                                    } else {
                                                        r15 = r17 != r18 ? 1 : 0;
                                                        r15 = r15 & 1;
                                                        if (r15 == 0) {
                                                            r15 = r1 >> numDefine2;
                                                            r15 = heapClassInst.heap32[r15];
                                                            r15 = r15 >> numDefine2;
                                                            r15 = heapClassInst.heap32[r15 + numDefine2];
                                                            r17 = heapClassInst.heap32[r14 + numDefine10];
                                                            r18 = heapClassInst.heap32[r14 + numDefine9];
                                                            heapClassInst.heap32[g0] = r1;
                                                            heapClassInst.heap32[g0 + 1] = r18;
                                                            heapClassInst.heap32[g0 + numDefine2] = r17;
                                                            functionTable.get(r15 >> numDefine2).accept(i7);
                                                            label = numDefine32;
                                                        } else {
                                                            label = numDefine32;
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                        if (label == numDefine30) {
                            r16 = heapClassInst.heap32[r14 + numDefine8];
                            r19 = -1;
                            r19 = r16 == r19 ? 1 : 0;
                            r16 = 0;
                        }
                        if (!(r16 != 0)) {
                            r15 = r19 & 1;
                            if (r15 == 0) {
                                r14 = heapClassInst.heap32[r14 + numDefine8];
                                r15 = r14 << numDefine6;
                                r6 = (r6 + r15) | 0;
                                r12 = (r14 + r12) | 0;
                                continue repeat15;
                            }
                        }
                        r6 = (r6 + numDefine64) | 0;
                        r12 = (r12 + 1) | 0;
                    } else {
                        label = numDefine13;
                        break repeat15;
                    }
                } else {
                    label = numDefine37;
                    break repeat15;
                }
            }
            switch (label) {
                case numDefine37:
                    r0 = maxIterations;
                    r0 = r0 >> numDefine2;
                    r1 = heapClassInst.heap32[r0];
                    if (!(r1 >= r13)) {
                        heapClassInst.heap32[r0] = r13;
                    }
                    return;
                case numDefine13:
                    r0 = twoEStr1921;
                    r1 = twoEStr537;
                    heapClassInst.heap32[g0] = r0;
                    heapClassInst.heap32[g0 + 1] = r1;
                    heapClassInst.heap32[g0 + numDefine2] = numDefine490;
                    assertNew(i7);
                    break;
                default:
                    break;
            }
        } else {
            r0 = twoEStr1844;
            r1 = twoEStr537;
            heapClassInst.heap32[g0] = r0;
            heapClassInst.heap32[g0 + 1] = r1;
            heapClassInst.heap32[g0 + numDefine2] = numDefine451;
            assertNew(i7);
        }
    }

    public static void zn30btActivatingCollisionAlgorithmD0Ev(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int label = 0;
        i7 = sp + numDefineNeg8;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = ztv30btActivatingCollisionAlgorithm;
        r2 = r0 >> numDefine2;
        r1 = (r1 + numDefine8) | 0;
        heapClassInst.heap32[r2] = r1;
        heapClassInst.heap32[g0] = r0;
        zdlPv(i7);
        
    }

    public static void zn30btActivatingCollisionAlgorithmD1Ev(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int label = 0;
        i7 = sp + 0;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = ztv30btActivatingCollisionAlgorithm;
        r0 = r0 >> numDefine2;
        r1 = (r1 + numDefine8) | 0;
        heapClassInst.heap32[r0] = r1;
        
    }

    public static void zn26btBoxBoxCollisionAlgorithm21calculateTimeOfImpactEP17btCollisionObjectS1RK16btDispatcherInfoP16btManifoldResult(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        float f0 = 0.0F;
        int label = 0;
        i7 = sp + 0;
        int g0 = i7 >> numDefine2;
        f0 = 1;
        commonVariable.fg0 = f0;
        
    }

    public static void zn26btBoxBoxCollisionAlgorithm22getAllContactManifoldsER20btAlignedObjectArrayIP20btPersistentManifoldE(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        int r6 = 0;
        int r7 = 0;
        int r8 = 0;
        int r9 = 0;
        int r10 = 0;
        int r11 = 0;
        int label = 0;
        i7 = sp + numDefineNeg8;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = r0 >> numDefine2;
        r2 = heapClassInst.heap32[r1 + numDefine3];
        if (!(r2 == 0)) {
            r0 = heapClassInst.heapU8[r0 + numDefine8];
            if (!(r0 == 0)) {
                r0 = heapClassInst.heap32[fp + 1];
                r3 = r0 >> numDefine2;
                r4 = heapClassInst.heap32[r3 + numDefine2];
                r5 = heapClassInst.heap32[r3 + 1];
                if (r4 == r5) {
                    r6 = 1;
                    r7 = r5 << 1;
                    r7 = r5 == 0 ? r6 : r7;
                    if (!(r4 >= r7)) {
                        if (r7 != 0) {
                            r2 = gNumAlignedAllocs;
                            r2 = r2 >> numDefine2;
                            r4 = heapClassInst.heap32[r2];
                            r8 = r7 << numDefine2;
                            r4 = (r4 + 1) | 0;
                            r8 = r8 | numDefine3;
                            heapClassInst.heap32[r2] = r4;
                            r2 = (r8 + numDefine16) | 0;
                            heapClassInst.heap32[g0] = r2;
                            mallocNew(i7);
                            r2 = commonVariable.rg0;
                            if (r2 != 0) {
                                r4 = 0;
                                r8 = (r2 + numDefine4) | 0;
                                r4 = (r4 - r8) | 0;
                                r4 = r4 & numDefine15;
                                r4 = (r2 + r4) | 0;
                                r8 = (r4 + numDefine4) | 0;
                                r4 = r4 >> numDefine2;
                                heapClassInst.heap32[r4] = r2;
                                r2 = r8;
                            }
                        } else {
                            r2 = 0;
                        }
                        r4 = (r0 + numDefine12) | 0;
                        if (r5 < 1) {
                            r8 = r4 >> numDefine2;
                            r9 = heapClassInst.heap32[r8];
                        } else {
                            r8 = 0;
                            repeat15:
                            while (true) {
                                r9 = r4 >> numDefine2;
                                r9 = heapClassInst.heap32[r9];
                                r10 = r8 << numDefine2;
                                r11 = (r9 + r10) | 0;
                                r11 = r11 >> numDefine2;
                                r10 = (r2 + r10) | 0;
                                r11 = heapClassInst.heap32[r11];
                                r8 = (r8 + 1) | 0;
                                r10 = r10 >> numDefine2;
                                heapClassInst.heap32[r10] = r11;
                                if (!(r5 != r8)) {
                                    break repeat15;
                                }
                            }
                            r4 = (r0 + numDefine12) | 0;
                        }
                        if (r9 != 0) {
                            r8 = heapClassInst.heapU8[r0 + numDefine16];
                            if (r8 != 0) {
                                r5 = gNumAlignedFree;
                                r5 = r5 >> numDefine2;
                                r8 = heapClassInst.heap32[r5];
                                r8 = (r8 + 1) | 0;
                                r9 = r9 >> numDefine2;
                                heapClassInst.heap32[r5] = r8;
                                r5 = heapClassInst.heap32[r9 + -1];
                                heapClassInst.heap32[g0] = r5;
                                free(i7);
                                r5 = heapClassInst.heap32[r3 + 1];
                            }
                            r8 = r4 >> numDefine2;
                            heapClassInst.heap32[r8] = 0;
                        }
                        r4 = r4 >> numDefine2;
                        heapClassInst.heap8[r0 + numDefine16] = (byte) r6;
                        heapClassInst.heap32[r4] = r2;
                        heapClassInst.heap32[r3 + numDefine2] = r7;
                        r2 = heapClassInst.heap32[r1 + numDefine3];
                    }
                }
                r0 = r5 << numDefine2;
                r1 = heapClassInst.heap32[r3 + numDefine3];
                r0 = (r1 + r0) | 0;
                r0 = r0 >> numDefine2;
                heapClassInst.heap32[r0] = r2;
                r0 = heapClassInst.heap32[r3 + 1];
                r0 = (r0 + 1) | 0;
                heapClassInst.heap32[r3 + 1] = r0;
            }
        }
        
    }

    public static void zn26btBoxBoxCollisionAlgorithm16processCollisionEP17btCollisionObjectS1RK16btDispatcherInfoP16btManifoldResult(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        int r6 = 0;
        int r7 = 0;
        int r8 = 0;
        int r9 = 0;
        int r10 = 0;
        int label = 0;
        i7 = sp + numDefineNeg176;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = r0 >> numDefine2;
        r1 = heapClassInst.heap32[r1 + numDefine3];
        if (!(r1 == 0)) {
            r2 = heapClassInst.heap32[fp + 1];
            r3 = heapClassInst.heap32[fp + numDefine2];
            r4 = heapClassInst.heap32[fp + numDefine3];
            r5 = heapClassInst.heap32[fp + numDefine4];
            r3 = r3 >> numDefine2;
            r2 = r2 >> numDefine2;
            r6 = heapClassInst.heap32[r3 + numDefine48];
            r7 = heapClassInst.heap32[r2 + numDefine48];
            r8 = sp + numDefineNeg136;
            r9 = r5 >> numDefine2;
            r10 = r8 >> numDefine2;
            heapClassInst.heap32[r9 + 1] = r1;
            heapClassInst.heap32[r10 + numDefine33] = 0;
            heapClassInst.heap32[r10 + numDefine32] = numDefine44395;
            heapClassInst.heap32[fp + numDefineNeg34] = heapClassInst.heap32[r2 + 1];
            heapClassInst.heap32[r10 + 1] = heapClassInst.heap32[r2 + numDefine2];
            heapClassInst.heap32[r10 + numDefine2] = heapClassInst.heap32[r2 + numDefine3];
            heapClassInst.heap32[r10 + numDefine3] = heapClassInst.heap32[r2 + numDefine4];
            heapClassInst.heap32[r10 + numDefine4] = heapClassInst.heap32[r2 + numDefine5];
            heapClassInst.heap32[r10 + numDefine5] = heapClassInst.heap32[r2 + numDefine6];
            heapClassInst.heap32[r10 + numDefine6] = heapClassInst.heap32[r2 + numDefine7];
            heapClassInst.heap32[r10 + numDefine7] = heapClassInst.heap32[r2 + numDefine8];
            heapClassInst.heap32[r10 + numDefine8] = heapClassInst.heap32[r2 + numDefine9];
            heapClassInst.heap32[r10 + numDefine9] = heapClassInst.heap32[r2 + numDefine10];
            heapClassInst.heap32[r10 + numDefine10] = heapClassInst.heap32[r2 + numDefine11];
            heapClassInst.heap32[r10 + numDefine11] = heapClassInst.heap32[r2 + numDefine12];
            heapClassInst.heap32[r10 + numDefine12] = heapClassInst.heap32[r2 + numDefine13];
            heapClassInst.heap32[r10 + numDefine13] = heapClassInst.heap32[r2 + numDefine14];
            heapClassInst.heap32[r10 + numDefine14] = heapClassInst.heap32[r2 + numDefine15];
            heapClassInst.heap32[r10 + numDefine15] = heapClassInst.heap32[r2 + numDefine16];
            heapClassInst.heap32[r10 + numDefine16] = heapClassInst.heap32[r3 + 1];
            heapClassInst.heap32[r10 + numDefine17] = heapClassInst.heap32[r3 + numDefine2];
            heapClassInst.heap32[r10 + numDefine18] = heapClassInst.heap32[r3 + numDefine3];
            heapClassInst.heap32[r10 + numDefine19] = heapClassInst.heap32[r3 + numDefine4];
            heapClassInst.heap32[r10 + numDefine20] = heapClassInst.heap32[r3 + numDefine5];
            heapClassInst.heap32[r10 + numDefine21] = heapClassInst.heap32[r3 + numDefine6];
            heapClassInst.heap32[r10 + numDefine22] = heapClassInst.heap32[r3 + numDefine7];
            heapClassInst.heap32[r10 + numDefine23] = heapClassInst.heap32[r3 + numDefine8];
            heapClassInst.heap32[r10 + numDefine24] = heapClassInst.heap32[r3 + numDefine9];
            heapClassInst.heap32[r10 + numDefine25] = heapClassInst.heap32[r3 + numDefine10];
            heapClassInst.heap32[r10 + numDefine26] = heapClassInst.heap32[r3 + numDefine11];
            heapClassInst.heap32[r10 + numDefine27] = heapClassInst.heap32[r3 + numDefine12];
            heapClassInst.heap32[r10 + numDefine28] = heapClassInst.heap32[r3 + numDefine13];
            heapClassInst.heap32[r10 + numDefine29] = heapClassInst.heap32[r3 + numDefine14];
            r1 = ztv16btBoxBoxDetector;
            heapClassInst.heap32[r10 + numDefine30] = heapClassInst.heap32[r3 + numDefine15];
            r2 = sp + numDefineNeg152;
            r1 = (r1 + numDefine8) | 0;
            heapClassInst.heap32[r10 + numDefine31] = heapClassInst.heap32[r3 + numDefine16];
            r3 = r2 >> numDefine2;
            heapClassInst.heap32[fp + numDefineNeg38] = r1;
            heapClassInst.heap32[r3 + 1] = r7;
            r1 = r4 >> numDefine2;
            heapClassInst.heap32[r3 + numDefine2] = r6;
            r1 = heapClassInst.heap32[r1 + numDefine5];
            heapClassInst.heap32[g0] = r2;
            heapClassInst.heap32[g0 + 1] = r8;
            heapClassInst.heap32[g0 + numDefine2] = r5;
            heapClassInst.heap32[g0 + numDefine3] = r1;
            heapClassInst.heap32[g0 + numDefine4] = 0;
            zn16btBoxBoxDetector16getClosestPointsERKN36btDiscreteCollisionDetectorInterface17ClosestPointInputERNS06ResultEP12btIDebugDrawb(i7);
            r0 = heapClassInst.heapU8[r0 + numDefine8];
            if (!(r0 == 0)) {
                r0 = heapClassInst.heap32[r9 + 1];
                if (r0 != 0) {
                    r1 = r0 >> numDefine2;
                    r2 = heapClassInst.heap32[r1 + numDefine279];
                    if (!(r2 == 0)) {
                        r1 = heapClassInst.heap32[r1 + numDefine277];
                        r2 = heapClassInst.heap32[r9 + numDefine34];
                        if (r1 == r2) {
                            r1 = (r5 + numDefine8) | 0;
                            r2 = (r5 + numDefine72) | 0;
                            heapClassInst.heap32[g0] = r0;
                            heapClassInst.heap32[g0 + 1] = r1;
                            heapClassInst.heap32[g0 + numDefine2] = r2;
                            zn20btPersistentManifold20refreshContactPointsERK11btTransformS2(i7);
                        } else {
                            r1 = (r5 + numDefine72) | 0;
                            r5 = (r5 + numDefine8) | 0;
                            heapClassInst.heap32[g0] = r0;
                            heapClassInst.heap32[g0 + 1] = r1;
                            heapClassInst.heap32[g0 + numDefine2] = r5;
                            zn20btPersistentManifold20refreshContactPointsERK11btTransformS2(i7);
                            
                        }
                    }
                } else {
                    r0 = twoEStr59;
                    r5 = twoEStr160;
                    heapClassInst.heap32[g0] = r0;
                    heapClassInst.heap32[g0 + 1] = r5;
                    heapClassInst.heap32[g0 + numDefine2] = numDefine101;
                    assertNew(i7);
                }
            }
        }
        
    }

    public static void zn26btBoxBoxCollisionAlgorithmD0Ev(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int label = 0;
        i7 = sp + numDefineNeg8;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = ztv26btBoxBoxCollisionAlgorithm;
        r2 = r0 >> numDefine2;
        r1 = (r1 + numDefine8) | 0;
        heapClassInst.heap32[r2] = r1;
        r1 = heapClassInst.heapU8[r0 + numDefine8];
        if (!(r1 == 0)) {
            r1 = heapClassInst.heap32[r2 + numDefine3];
            if (!(r1 == 0)) {
                r3 = heapClassInst.heap32[r2 + 1];
                r4 = r3 >> numDefine2;
                r4 = heapClassInst.heap32[r4];
                r4 = r4 >> numDefine2;
                r4 = heapClassInst.heap32[r4 + numDefine4];
                heapClassInst.heap32[g0] = r3;
                heapClassInst.heap32[g0 + 1] = r1;
                functionTable.get(r4 >> numDefine2).accept(i7);
            }
        }
        r1 = ztv30btActivatingCollisionAlgorithm;
        r1 = (r1 + numDefine8) | 0;
        heapClassInst.heap32[r2] = r1;
        heapClassInst.heap32[g0] = r0;
        zdlPv(i7);
        
    }

    public static void zn26btBoxBoxCollisionAlgorithmD1Ev(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int label = 0;
        i7 = sp + numDefineNeg8;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = ztv26btBoxBoxCollisionAlgorithm;
        r2 = r0 >> numDefine2;
        r1 = (r1 + numDefine8) | 0;
        heapClassInst.heap32[r2] = r1;
        r0 = heapClassInst.heapU8[r0 + numDefine8];
        if (!(r0 == 0)) {
            r0 = heapClassInst.heap32[r2 + numDefine3];
            if (!(r0 == 0)) {
                r1 = heapClassInst.heap32[r2 + 1];
                r3 = r1 >> numDefine2;
                r3 = heapClassInst.heap32[r3];
                r3 = r3 >> numDefine2;
                r3 = heapClassInst.heap32[r3 + numDefine4];
                heapClassInst.heap32[g0] = r1;
                heapClassInst.heap32[g0 + 1] = r0;
                functionTable.get(r3 >> numDefine2).accept(i7);
            }
        }
        r0 = ztv30btActivatingCollisionAlgorithm;
        r0 = (r0 + numDefine8) | 0;
        heapClassInst.heap32[r2] = r0;
        
    }

    public static void zn16btBoxBoxDetectorD1Ev(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int label = 0;
        i7 = sp + 0;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = ztv16btBoxBoxDetector;
        r0 = r0 >> numDefine2;
        r1 = (r1 + numDefine8) | 0;
        heapClassInst.heap32[r0] = r1;
        
    }

    public static void zn16btBoxBoxDetectorD0Ev(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int label = 0;
        i7 = sp + numDefineNeg8;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = ztv16btBoxBoxDetector;
        r2 = r0 >> numDefine2;
        r1 = (r1 + numDefine8) | 0;
        heapClassInst.heap32[r2] = r1;
        heapClassInst.heap32[g0] = r0;
        zdlPv(i7);
        
    }

    public static void zn16btBoxBoxDetector16getClosestPointsERKN36btDiscreteCollisionDetectorInterface17ClosestPointInputERNS06ResultEP12btIDebugDrawb(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        int r6 = 0;
        int r7 = 0;
        int r8 = 0;
        int r9 = 0;
        int r10 = 0;
        int r11 = 0;
        int r12 = 0;
        int r13 = 0;
        int r14 = 0;
        int r15 = 0;
        int r16 = 0;
        int r17 = 0;
        int r18 = 0;
        int r19 = 0;
        int r20 = 0;
        int r21 = 0;
        int r22 = 0;
        int r23 = 0;
        int r24 = 0;
        int r25 = 0;
        float f0 = 0.0F;
        float f1 = 0.0F;
        float f2 = 0.0F;
        float f3 = 0.0F;
        float f4 = 0.0F;
        float f5 = 0.0F;
        float f6 = 0.0F;
        float f7 = 0.0F;
        float f8 = 0.0F;
        float f9 = 0.0F;
        float f10 = 0.0F;
        float f11 = 0.0F;
        float f12 = 0.0F;
        float f13 = 0.0F;
        float f14 = 0.0F;
        float f15 = 0.0F;
        float f16 = 0.0F;
        float f17 = 0.0F;
        float f18 = 0.0F;
        float f19 = 0.0F;
        float f20 = 0.0F;
        float f21 = 0.0F;
        float f22 = 0.0F;
        float f23 = 0.0F;
        float f24 = 0.0F;
        float f25 = 0.0F;
        float f26 = 0.0F;
        float f27 = 0.0F;
        float f28 = 0.0F;
        float f29 = 0.0F;
        float f30 = 0.0F;
        int label = 0;
        i7 = sp + numDefineNeg808;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp + 1];
        r1 = r0 >> numDefine2;
        r2 = sp + numDefineNeg640;
        heapClassInst.heap32[fp + numDefineNeg160] = heapClassInst.heap32[r1];
        r3 = sp + numDefineNeg688;
        heapClassInst.heap32[fp + numDefineNeg172] = heapClassInst.heap32[r1 + numDefine16];
        r4 = r2 >> numDefine2;
        r5 = r3 >> numDefine2;
        heapClassInst.heap32[r4 + 1] = heapClassInst.heap32[r1 + 1];
        heapClassInst.heap32[r5 + 1] = heapClassInst.heap32[r1 + numDefine17];
        heapClassInst.heap32[r4 + numDefine2] = heapClassInst.heap32[r1 + numDefine2];
        heapClassInst.heap32[r5 + numDefine2] = heapClassInst.heap32[r1 + numDefine18];
        heapClassInst.heap32[r4 + numDefine4] = heapClassInst.heap32[r1 + numDefine4];
        heapClassInst.heap32[r5 + numDefine4] = heapClassInst.heap32[r1 + numDefine20];
        heapClassInst.heap32[r4 + numDefine5] = heapClassInst.heap32[r1 + numDefine5];
        heapClassInst.heap32[r5 + numDefine5] = heapClassInst.heap32[r1 + numDefine21];
        heapClassInst.heap32[r4 + numDefine6] = heapClassInst.heap32[r1 + numDefine6];
        heapClassInst.heap32[r5 + numDefine6] = heapClassInst.heap32[r1 + numDefine22];
        heapClassInst.heap32[r4 + numDefine8] = heapClassInst.heap32[r1 + numDefine8];
        heapClassInst.heap32[r5 + numDefine8] = heapClassInst.heap32[r1 + numDefine24];
        heapClassInst.heap32[r4 + numDefine9] = heapClassInst.heap32[r1 + numDefine9];
        heapClassInst.heap32[r5 + numDefine9] = heapClassInst.heap32[r1 + numDefine25];
        r6 = heapClassInst.heap32[fp];
        heapClassInst.heap32[r4 + numDefine10] = heapClassInst.heap32[r1 + numDefine10];
        r6 = r6 >> numDefine2;
        heapClassInst.heap32[r5 + numDefine10] = heapClassInst.heap32[r1 + numDefine26];
        r7 = heapClassInst.heap32[r6 + numDefine2];
        r8 = r7 >> numDefine2;
        r9 = heapClassInst.heap32[r8];
        r9 = r9 >> numDefine2;
        r9 = heapClassInst.heap32[r9 + numDefine11];
        f0 = heapClassInst.heapFloat[r8 + numDefine7];
        f1 = heapClassInst.heapFloat[r8 + numDefine8];
        f2 = heapClassInst.heapFloat[r8 + numDefine9];
        heapClassInst.heap32[g0] = r7;
        functionTable.get(r9 >> numDefine2).accept(i7);
        f3 = (float) commonVariable.fg0;
        r9 = heapClassInst.heap32[r8];
        r9 = r9 >> numDefine2;
        r9 = heapClassInst.heap32[r9 + numDefine11];
        heapClassInst.heap32[g0] = r7;
        functionTable.get(r9 >> numDefine2).accept(i7);
        f4 = (float) commonVariable.fg0;
        r8 = heapClassInst.heap32[r8];
        r8 = r8 >> numDefine2;
        r8 = heapClassInst.heap32[r8 + numDefine11];
        heapClassInst.heap32[g0] = r7;
        functionTable.get(r8 >> numDefine2).accept(i7);
        f5 = (float) commonVariable.fg0;
        r6 = heapClassInst.heap32[r6 + 1];
        r7 = r6 >> numDefine2;
        r8 = heapClassInst.heap32[r7];
        r8 = r8 >> numDefine2;
        f6 = heapClassInst.heapFloat[r7 + numDefine8];
        r8 = heapClassInst.heap32[r8 + numDefine11];
        f7 = heapClassInst.heapFloat[r7 + numDefine9];
        f8 = heapClassInst.heapFloat[r7 + numDefine7];
        heapClassInst.heap32[g0] = r6;
        functionTable.get(r8 >> numDefine2).accept(i7);
        f9 = (float) commonVariable.fg0;
        r8 = heapClassInst.heap32[r7];
        r8 = r8 >> numDefine2;
        r8 = heapClassInst.heap32[r8 + numDefine11];
        heapClassInst.heap32[g0] = r6;
        functionTable.get(r8 >> numDefine2).accept(i7);
        f10 = (float) commonVariable.fg0;
        r7 = heapClassInst.heap32[r7];
        r7 = r7 >> numDefine2;
        r7 = heapClassInst.heap32[r7 + numDefine11];
        heapClassInst.heap32[g0] = r6;
        functionTable.get(r7 >> numDefine2).accept(i7);
        f8 = (float) (f8 + commonVariable.fg0);
        f6 = f6 + f10;
        f8 = f8 + f8;
        f10 = (float) numDefineFloat05;
        heapClassInst.heapFloat[fp + numDefineNeg187] = f10;
        f11 = heapClassInst.heapFloat[r1 + numDefine30];
        f12 = heapClassInst.heapFloat[r1 + numDefine14];
        f13 = heapClassInst.heapFloat[r1 + numDefine29];
        f14 = heapClassInst.heapFloat[r1 + numDefine13];
        f15 = heapClassInst.heapFloat[r1 + numDefine28];
        f16 = heapClassInst.heapFloat[r1 + numDefine12];
        f17 = heapClassInst.heapFloat[fp + numDefineNeg160];
        f18 = heapClassInst.heapFloat[r4 + numDefine4];
        f19 = heapClassInst.heapFloat[r4 + numDefine8];
        f20 = heapClassInst.heapFloat[r4 + 1];
        f21 = heapClassInst.heapFloat[r4 + numDefine5];
        f22 = heapClassInst.heapFloat[r4 + numDefine9];
        f23 = heapClassInst.heapFloat[r4 + numDefine2];
        f24 = heapClassInst.heapFloat[r4 + numDefine6];
        f25 = heapClassInst.heapFloat[r4 + numDefine10];
        r4 = sp + numDefineNeg236;
        f7 = f7 + f9;
        f6 = f6 + f6;
        f8 = f8 * f10;
        heapClassInst.heapFloat[fp + numDefineNeg179] = f8;
        f0 = f0 + f5;
        f5 = f7 + f7;
        f6 = f6 * f10;
        heapClassInst.heapFloat[fp + numDefineNeg178] = f6;
        r6 = r4 >> numDefine2;
        heapClassInst.heapFloat[fp + numDefineNeg59] = f8;
        f1 = f1 + f4;
        f0 = f0 + f0;
        f4 = f5 * f10;
        heapClassInst.heapFloat[fp + numDefineNeg177] = f4;
        heapClassInst.heapFloat[r6 + 1] = f6;
        r7 = sp + numDefineNeg248;
        heapClassInst.heap32[fp + numDefineNeg186] = r7;
        f2 = f2 + f3;
        f1 = f1 + f1;
        f0 = f0 * f10;
        heapClassInst.heapFloat[fp + numDefineNeg181] = f0;
        heapClassInst.heapFloat[r6 + numDefine2] = f4;
        f2 = f2 + f2;
        f1 = f1 * f10;
        heapClassInst.heapFloat[fp + numDefineNeg182] = f1;
        r6 = r7 >> numDefine2;
        heapClassInst.heapFloat[fp + numDefineNeg62] = f0;
        f0 = f2 * f10;
        heapClassInst.heapFloat[fp + numDefineNeg180] = f0;
        heapClassInst.heapFloat[r6 + 1] = f1;
        heapClassInst.heapFloat[r6 + numDefine2] = f0;
        f0 = f15 - f16;
        heapClassInst.heapFloat[fp + numDefineNeg183] = f0;
        f1 = f13 - f14;
        heapClassInst.heapFloat[fp + numDefineNeg184] = f1;
        f2 = heapClassInst.heapFloat[fp + numDefineNeg172];
        heapClassInst.heapFloat[fp + numDefineNeg194] = f2;
        f3 = heapClassInst.heapFloat[r5 + numDefine4];
        heapClassInst.heapFloat[fp + numDefineNeg195] = f3;
        f4 = heapClassInst.heapFloat[r5 + 1];
        heapClassInst.heapFloat[fp + numDefineNeg191] = f4;
        f5 = heapClassInst.heapFloat[r5 + numDefine5];
        heapClassInst.heapFloat[fp + numDefineNeg192] = f5;
        f6 = heapClassInst.heapFloat[r5 + numDefine2];
        heapClassInst.heapFloat[fp + numDefineNeg188] = f6;
        f7 = heapClassInst.heapFloat[r5 + numDefine6];
        heapClassInst.heapFloat[fp + numDefineNeg189] = f7;
        f8 = f11 - f12;
        heapClassInst.heapFloat[fp + numDefineNeg185] = f8;
        f9 = heapClassInst.heapFloat[r5 + numDefine8];
        heapClassInst.heapFloat[fp + numDefineNeg196] = f9;
        f10 = heapClassInst.heapFloat[r5 + numDefine9];
        heapClassInst.heapFloat[fp + numDefineNeg193] = f10;
        f11 = heapClassInst.heapFloat[r5 + numDefine10];
        heapClassInst.heapFloat[fp + numDefineNeg190] = f11;
        f12 = f17 * f2;
        f13 = f18 * f3;
        f14 = f17 * f0;
        f15 = f18 * f1;
        f16 = f20 * f0;
        f26 = f21 * f1;
        f0 = f23 * f0;
        heapClassInst.heapFloat[fp + numDefineNeg198] = f0;
        f1 = f24 * f1;
        f27 = f17 * f4;
        f28 = f18 * f5;
        f17 = f17 * f6;
        f18 = f18 * f7;
        f29 = f20 * f2;
        f30 = f21 * f3;
        f0 = f20 * f4;
        heapClassInst.heapFloat[fp + numDefineNeg197] = f0;
        f0 = f21 * f5;
        f20 = f20 * f6;
        f21 = f21 * f7;
        f2 = f23 * f2;
        f3 = f24 * f3;
        f4 = f23 * f4;
        f5 = f24 * f5;
        f6 = f23 * f6;
        f7 = f24 * f7;
        f12 = f12 + f13;
        f13 = f19 * f9;
        f14 = f14 + f15;
        f15 = f19 * f8;
        f16 = f16 + f26;
        f23 = f22 * f8;
        f24 = heapClassInst.heapFloat[fp + numDefineNeg198];
        f1 = f24 + f1;
        f8 = f25 * f8;
        f24 = f27 + f28;
        f26 = f19 * f10;
        f17 = f17 + f18;
        f18 = f19 * f11;
        f19 = f29 + f30;
        f27 = f22 * f9;
        f28 = heapClassInst.heapFloat[fp + numDefineNeg197];
        f0 = f28 + f0;
        f28 = f22 * f10;
        f20 = f20 + f21;
        f21 = f22 * f11;
        f2 = f2 + f3;
        f3 = f25 * f9;
        f4 = f4 + f5;
        f5 = f25 * f10;
        f6 = f6 + f7;
        f7 = f25 * f11;
        f9 = f12 + f13;
        r5 = heapClassInst.heap32[fp + numDefine2];
        r6 = (r2 + numDefine4) | 0;
        r7 = (r3 + numDefine4) | 0;
        r8 = (r2 + numDefine8) | 0;
        r9 = (r3 + numDefine8) | 0;
        r10 = (r0 + numDefine112) | 0;
        r0 = (r0 + numDefine48) | 0;
        f10 = f14 + f15;
        f11 = f16 + f23;
        f1 = f1 + f8;
        f8 = f24 + f26;
        f12 = f17 + f18;
        f13 = f19 + f27;
        f0 = f0 + f28;
        f14 = f20 + f21;
        f2 = f2 + f3;
        f3 = f4 + f5;
        f4 = f6 + f7;
        f5 = 0;
        if (f9 < f5) {
            f6 = -f9;
        } else {
            f6 = f9;
        }
        if (f8 < f5) {
            f7 = -f8;
        } else {
            f7 = f8;
        }
        if (f12 < f5) {
            f15 = -f12;
        } else {
            f15 = f12;
        }
        if (f13 < f5) {
            f16 = -f13;
        } else {
            f16 = f13;
        }
        if (f0 < f5) {
            f17 = -f0;
        } else {
            f17 = f0;
        }
        if (f14 < f5) {
            f18 = -f14;
        } else {
            f18 = f14;
        }
        if (f2 < f5) {
            f19 = -f2;
        } else {
            f19 = f2;
        }
        if (f3 < f5) {
            f20 = -f3;
        } else {
            f20 = f3;
        }
        if (f4 < f5) {
            f21 = -f4;
        } else {
            f21 = f4;
        }
        if (f10 < f5) {
            f22 = -f10;
        } else {
            f22 = f10;
        }
        f23 = heapClassInst.heapFloat[fp + numDefineNeg181];
        f23 = f23 * f6;
        f24 = heapClassInst.heapFloat[fp + numDefineNeg179];
        f23 = f24 + f23;
        f24 = heapClassInst.heapFloat[fp + numDefineNeg182];
        f24 = f24 * f7;
        f23 = f23 + f24;
        f24 = heapClassInst.heapFloat[fp + numDefineNeg180];
        f24 = f24 * f15;
        f23 = f23 + f24;
        f22 = f22 - f23;
        repeat41:
        do {
            if (!(f22 > f5)) {
                f23 = (float) numDefineNegFloat4868;
                if (f22 > f23) {
                    f23 = 0;
                    r11 = f10 < f23 ? 1 : 0;
                    r13 = sp + numDefineNeg640;
                    r11 = r11 & 1;
                    r12 = 1;
                    f23 = f22;
                } else {
                    r11 = 0;
                    r12 = r11;
                    r13 = r11;
                }
                if (f11 < f5) {
                    f22 = -f11;
                } else {
                    f22 = f11;
                }
                f24 = heapClassInst.heapFloat[fp + numDefineNeg181];
                f24 = f24 * f16;
                f25 = heapClassInst.heapFloat[fp + numDefineNeg178];
                f24 = f25 + f24;
                f25 = heapClassInst.heapFloat[fp + numDefineNeg182];
                f25 = f25 * f17;
                f24 = f24 + f25;
                f25 = heapClassInst.heapFloat[fp + numDefineNeg180];
                f25 = f25 * f18;
                f24 = f24 + f25;
                f22 = f22 - f24;
                if (!(f22 > f5)) {
                    if (f22 > f23) {
                        f23 = 0;
                        r11 = f11 < f23 ? 1 : 0;
                        r11 = r11 & 1;
                        r12 = numDefine2;
                        f23 = f22;
                        r13 = r6;
                    }
                    if (f1 < f5) {
                        f22 = -f1;
                    } else {
                        f22 = f1;
                    }
                    f24 = heapClassInst.heapFloat[fp + numDefineNeg181];
                    f24 = f24 * f19;
                    f25 = heapClassInst.heapFloat[fp + numDefineNeg177];
                    f24 = f25 + f24;
                    f25 = heapClassInst.heapFloat[fp + numDefineNeg182];
                    f25 = f25 * f20;
                    f24 = f24 + f25;
                    f25 = heapClassInst.heapFloat[fp + numDefineNeg180];
                    f25 = f25 * f21;
                    f24 = f24 + f25;
                    f22 = f22 - f24;
                    if (!(f22 > f5)) {
                        if (f22 > f23) {
                            f23 = 0;
                            r11 = f1 < f23 ? 1 : 0;
                            r11 = r11 & 1;
                            r12 = numDefine3;
                            f23 = f22;
                            r13 = r8;
                        }
                        f24 = heapClassInst.heapFloat[fp + numDefineNeg183];
                        f22 = heapClassInst.heapFloat[fp + numDefineNeg194];
                        f22 = f22 * f24;
                        f25 = heapClassInst.heapFloat[fp + numDefineNeg184];
                        f24 = heapClassInst.heapFloat[fp + numDefineNeg195];
                        f24 = f24 * f25;
                        f22 = f22 + f24;
                        f25 = heapClassInst.heapFloat[fp + numDefineNeg185];
                        f24 = heapClassInst.heapFloat[fp + numDefineNeg196];
                        f24 = f24 * f25;
                        f22 = f22 + f24;
                        if (f22 < f5) {
                            f24 = -f22;
                        } else {
                            f24 = f22;
                        }
                        f25 = heapClassInst.heapFloat[fp + numDefineNeg179];
                        f25 = f25 * f6;
                        f26 = heapClassInst.heapFloat[fp + numDefineNeg178];
                        f26 = f26 * f16;
                        f25 = f25 + f26;
                        f26 = heapClassInst.heapFloat[fp + numDefineNeg177];
                        f26 = f26 * f19;
                        f25 = f25 + f26;
                        f26 = heapClassInst.heapFloat[fp + numDefineNeg181];
                        f25 = f25 + f26;
                        f24 = f24 - f25;
                        if (!(f24 > f5)) {
                            if (f24 > f23) {
                                f23 = 0;
                                r11 = f22 < f23 ? 1 : 0;
                                r13 = sp + numDefineNeg688;
                                r11 = r11 & 1;
                                r12 = numDefine4;
                                f23 = f24;
                            }
                            f24 = heapClassInst.heapFloat[fp + numDefineNeg183];
                            f22 = heapClassInst.heapFloat[fp + numDefineNeg191];
                            f22 = f22 * f24;
                            f25 = heapClassInst.heapFloat[fp + numDefineNeg184];
                            f24 = heapClassInst.heapFloat[fp + numDefineNeg192];
                            f24 = f24 * f25;
                            f22 = f22 + f24;
                            f25 = heapClassInst.heapFloat[fp + numDefineNeg185];
                            f24 = heapClassInst.heapFloat[fp + numDefineNeg193];
                            f24 = f24 * f25;
                            f22 = f22 + f24;
                            if (f22 < f5) {
                                f24 = -f22;
                            } else {
                                f24 = f22;
                            }
                            f25 = heapClassInst.heapFloat[fp + numDefineNeg179];
                            f25 = f25 * f7;
                            f26 = heapClassInst.heapFloat[fp + numDefineNeg178];
                            f26 = f26 * f17;
                            f25 = f25 + f26;
                            f26 = heapClassInst.heapFloat[fp + numDefineNeg177];
                            f26 = f26 * f20;
                            f25 = f25 + f26;
                            f26 = heapClassInst.heapFloat[fp + numDefineNeg182];
                            f25 = f25 + f26;
                            f24 = f24 - f25;
                            if (!(f24 > f5)) {
                                if (f24 > f23) {
                                    f23 = 0;
                                    r11 = f22 < f23 ? 1 : 0;
                                    r11 = r11 & 1;
                                    r12 = numDefine5;
                                    f23 = f24;
                                    r13 = r7;
                                }
                                f24 = heapClassInst.heapFloat[fp + numDefineNeg183];
                                f22 = heapClassInst.heapFloat[fp + numDefineNeg188];
                                f22 = f22 * f24;
                                f25 = heapClassInst.heapFloat[fp + numDefineNeg184];
                                f24 = heapClassInst.heapFloat[fp + numDefineNeg189];
                                f24 = f24 * f25;
                                f22 = f22 + f24;
                                f25 = heapClassInst.heapFloat[fp + numDefineNeg185];
                                f24 = heapClassInst.heapFloat[fp + numDefineNeg190];
                                f24 = f24 * f25;
                                f22 = f22 + f24;
                                if (f22 < f5) {
                                    f24 = -f22;
                                } else {
                                    f24 = f22;
                                }
                                f25 = heapClassInst.heapFloat[fp + numDefineNeg179];
                                f25 = f25 * f15;
                                f26 = heapClassInst.heapFloat[fp + numDefineNeg178];
                                f26 = f26 * f18;
                                f25 = f25 + f26;
                                f26 = heapClassInst.heapFloat[fp + numDefineNeg177];
                                f26 = f26 * f21;
                                f25 = f25 + f26;
                                f26 = heapClassInst.heapFloat[fp + numDefineNeg180];
                                f25 = f25 + f26;
                                f24 = f24 - f25;
                                if (!(f24 > f5)) {
                                    if (f24 > f23) {
                                        f23 = 0;
                                        r11 = f22 < f23 ? 1 : 0;
                                        r11 = r11 & 1;
                                        r12 = numDefine6;
                                        f23 = f24;
                                        r13 = r9;
                                    }
                                    f22 = f1 * f13;
                                    f24 = f11 * f2;
                                    f25 = (float) numDefineFloat9166;
                                    f22 = f22 - f24;
                                    f6 = f6 + f25;
                                    f7 = f7 + f25;
                                    f15 = f15 + f25;
                                    heapClassInst.heapFloat[fp + numDefineNeg183] = f15;
                                    f15 = f16 + f25;
                                    f16 = f17 + f25;
                                    f17 = f18 + f25;
                                    f18 = f19 + f25;
                                    heapClassInst.heapFloat[fp + numDefineNeg184] = f18;
                                    f18 = f20 + f25;
                                    heapClassInst.heapFloat[fp + numDefineNeg185] = f18;
                                    f18 = f21 + f25;
                                    if (f22 < f5) {
                                        f19 = -f22;
                                    } else {
                                        f19 = f22;
                                    }
                                    f21 = heapClassInst.heapFloat[fp + numDefineNeg184];
                                    f20 = heapClassInst.heapFloat[fp + numDefineNeg178];
                                    f20 = f20 * f21;
                                    f21 = heapClassInst.heapFloat[fp + numDefineNeg177];
                                    f21 = f21 * f15;
                                    f20 = f20 + f21;
                                    f24 = heapClassInst.heapFloat[fp + numDefineNeg183];
                                    f21 = heapClassInst.heapFloat[fp + numDefineNeg182];
                                    f21 = f21 * f24;
                                    f20 = f20 + f21;
                                    f21 = heapClassInst.heapFloat[fp + numDefineNeg180];
                                    f21 = f21 * f7;
                                    f20 = f20 + f21;
                                    f19 = f19 - f20;
                                    f20 = (float) numDefineFloat1257;
                                    if (!(f19 > f20)) {
                                        f21 = f2 * f2;
                                        f21 = f21 + f5;
                                        f24 = f13 * f13;
                                        heapClassInst.heapFloat[fp + numDefineNeg188] = f24;
                                        f24 = f21 + f24;
                                        heapClassInst.heapFloat[g0] = f24;
                                        sqrtf(i7);
                                        f24 = (float) commonVariable.fg0;
                                        if (f24 > f20) {
                                            f25 = f19 / f24;
                                            f19 = (float) numDefineFloat042;
                                            f19 = f25 * f19;
                                            if (f19 <= f23) {
                                                label = numDefine69;
                                            } else {
                                                f19 = 0;
                                                f23 = -f2;
                                                r11 = f22 < f19 ? 1 : 0;
                                                f19 = f19 / f24;
                                                f22 = f23 / f24;
                                                f24 = f13 / f24;
                                                r11 = r11 & 1;
                                                r12 = numDefine7;
                                                r13 = 0;
                                                f23 = f25;
                                                label = numDefine72;
                                            }
                                        } else {
                                            label = numDefine69;
                                        }
                                        if (label == numDefine69) {
                                            f19 = f5;
                                            f22 = f5;
                                            f24 = f5;
                                        }
                                        f25 = f1 * f0;
                                        f26 = f11 * f3;
                                        f25 = f25 - f26;
                                        if (f25 < f5) {
                                            f5 = -f25;
                                        } else {
                                            f5 = f25;
                                        }
                                        f27 = heapClassInst.heapFloat[fp + numDefineNeg185];
                                        f26 = heapClassInst.heapFloat[fp + numDefineNeg178];
                                        f26 = f26 * f27;
                                        f27 = heapClassInst.heapFloat[fp + numDefineNeg177];
                                        f27 = f27 * f16;
                                        f26 = f26 + f27;
                                        f28 = heapClassInst.heapFloat[fp + numDefineNeg183];
                                        f27 = heapClassInst.heapFloat[fp + numDefineNeg181];
                                        f27 = f27 * f28;
                                        f26 = f26 + f27;
                                        f27 = heapClassInst.heapFloat[fp + numDefineNeg180];
                                        f27 = f27 * f6;
                                        f26 = f26 + f27;
                                        f5 = f5 - f26;
                                        if (!(f5 > f20)) {
                                            f26 = f3 * f3;
                                            f27 = 0;
                                            f26 = f26 + f27;
                                            f28 = f0 * f0;
                                            heapClassInst.heapFloat[fp + numDefineNeg189] = f28;
                                            f28 = f26 + f28;
                                            heapClassInst.heapFloat[g0] = f28;
                                            sqrtf(i7);
                                            f28 = (float) commonVariable.fg0;
                                            if (f28 > f20) {
                                                f5 = f5 / f28;
                                                f29 = (float) numDefineFloat042;
                                                f29 = f5 * f29;
                                                if (!(f29 <= f23)) {
                                                    f19 = 0;
                                                    f22 = -f3;
                                                    r11 = f25 < f19 ? 1 : 0;
                                                    f19 = f19 / f28;
                                                    f22 = f22 / f28;
                                                    f24 = f0 / f28;
                                                    r11 = r11 & 1;
                                                    r12 = numDefine8;
                                                    r13 = 0;
                                                    f23 = f5;
                                                }
                                            }
                                            f5 = f1 * f14;
                                            f25 = f11 * f4;
                                            f5 = f5 - f25;
                                            if (f5 < f27) {
                                                f25 = -f5;
                                            } else {
                                                f25 = f5;
                                            }
                                            f28 = heapClassInst.heapFloat[fp + numDefineNeg178];
                                            f28 = f28 * f18;
                                            f29 = heapClassInst.heapFloat[fp + numDefineNeg177];
                                            f29 = f29 * f17;
                                            f28 = f28 + f29;
                                            f29 = heapClassInst.heapFloat[fp + numDefineNeg181];
                                            f29 = f29 * f7;
                                            f28 = f28 + f29;
                                            f29 = heapClassInst.heapFloat[fp + numDefineNeg182];
                                            f29 = f29 * f6;
                                            f28 = f28 + f29;
                                            f25 = f25 - f28;
                                            if (!(f25 > f20)) {
                                                f28 = f4 * f4;
                                                f28 = f28 + f27;
                                                f29 = f14 * f14;
                                                heapClassInst.heapFloat[fp + numDefineNeg190] = f29;
                                                f29 = f28 + f29;
                                                heapClassInst.heapFloat[g0] = f29;
                                                sqrtf(i7);
                                                f29 = (float) commonVariable.fg0;
                                                if (f29 > f20) {
                                                    f25 = f25 / f29;
                                                    f30 = (float) numDefineFloat042;
                                                    f30 = f25 * f30;
                                                    if (!(f30 <= f23)) {
                                                        f19 = 0;
                                                        f22 = -f4;
                                                        r11 = f5 < f19 ? 1 : 0;
                                                        f19 = f19 / f29;
                                                        f22 = f22 / f29;
                                                        f24 = f14 / f29;
                                                        r11 = r11 & 1;
                                                        r12 = numDefine9;
                                                        r13 = 0;
                                                        f23 = f25;
                                                    }
                                                }
                                                f5 = f10 * f2;
                                                f25 = f1 * f9;
                                                f5 = f5 - f25;
                                                if (f5 < f27) {
                                                    f25 = -f5;
                                                } else {
                                                    f25 = f5;
                                                }
                                                f30 = heapClassInst.heapFloat[fp + numDefineNeg184];
                                                f29 = heapClassInst.heapFloat[fp + numDefineNeg179];
                                                f29 = f29 * f30;
                                                f30 = heapClassInst.heapFloat[fp + numDefineNeg177];
                                                f30 = f30 * f6;
                                                f29 = f29 + f30;
                                                f30 = heapClassInst.heapFloat[fp + numDefineNeg182];
                                                f30 = f30 * f17;
                                                f29 = f29 + f30;
                                                f30 = heapClassInst.heapFloat[fp + numDefineNeg180];
                                                f30 = f30 * f16;
                                                f29 = f29 + f30;
                                                f25 = f25 - f29;
                                                if (!(f25 > f20)) {
                                                    f29 = f9 * f9;
                                                    f21 = f21 + f29;
                                                    heapClassInst.heapFloat[g0] = f21;
                                                    sqrtf(i7);
                                                    f21 = (float) commonVariable.fg0;
                                                    if (f21 > f20) {
                                                        f25 = f25 / f21;
                                                        f30 = (float) numDefineFloat042;
                                                        f30 = f25 * f30;
                                                        if (!(f30 <= f23)) {
                                                            f22 = 0;
                                                            f23 = -f9;
                                                            r11 = f5 < f22 ? 1 : 0;
                                                            f19 = f2 / f21;
                                                            f22 = f22 / f21;
                                                            f24 = f23 / f21;
                                                            r11 = r11 & 1;
                                                            r12 = numDefine10;
                                                            r13 = 0;
                                                            f23 = f25;
                                                        }
                                                    }
                                                    f2 = f10 * f3;
                                                    f5 = f1 * f8;
                                                    f2 = f2 - f5;
                                                    if (f2 < f27) {
                                                        f5 = -f2;
                                                    } else {
                                                        f5 = f2;
                                                    }
                                                    f25 = heapClassInst.heapFloat[fp + numDefineNeg185];
                                                    f21 = heapClassInst.heapFloat[fp + numDefineNeg179];
                                                    f21 = f21 * f25;
                                                    f25 = heapClassInst.heapFloat[fp + numDefineNeg177];
                                                    f25 = f25 * f7;
                                                    f21 = f21 + f25;
                                                    f25 = heapClassInst.heapFloat[fp + numDefineNeg181];
                                                    f25 = f25 * f17;
                                                    f21 = f21 + f25;
                                                    f25 = heapClassInst.heapFloat[fp + numDefineNeg180];
                                                    f25 = f25 * f15;
                                                    f21 = f21 + f25;
                                                    f5 = f5 - f21;
                                                    if (!(f5 > f20)) {
                                                        f21 = f8 * f8;
                                                        f25 = f26 + f21;
                                                        heapClassInst.heapFloat[g0] = f25;
                                                        sqrtf(i7);
                                                        f25 = (float) commonVariable.fg0;
                                                        if (f25 > f20) {
                                                            f5 = f5 / f25;
                                                            f26 = (float) numDefineFloat042;
                                                            f26 = f5 * f26;
                                                            if (!(f26 <= f23)) {
                                                                f22 = 0;
                                                                f23 = -f8;
                                                                r11 = f2 < f22 ? 1 : 0;
                                                                f19 = f3 / f25;
                                                                f22 = f22 / f25;
                                                                f24 = f23 / f25;
                                                                r11 = r11 & 1;
                                                                r12 = numDefine11;
                                                                r13 = 0;
                                                                f23 = f5;
                                                            }
                                                        }
                                                        f2 = f10 * f4;
                                                        f1 = f1 * f12;
                                                        f1 = f2 - f1;
                                                        if (f1 < f27) {
                                                            f2 = -f1;
                                                        } else {
                                                            f2 = f1;
                                                        }
                                                        f3 = heapClassInst.heapFloat[fp + numDefineNeg179];
                                                        f3 = f3 * f18;
                                                        f25 = heapClassInst.heapFloat[fp + numDefineNeg183];
                                                        f5 = heapClassInst.heapFloat[fp + numDefineNeg177];
                                                        f5 = f5 * f25;
                                                        f3 = f3 + f5;
                                                        f5 = heapClassInst.heapFloat[fp + numDefineNeg181];
                                                        f5 = f5 * f16;
                                                        f3 = f3 + f5;
                                                        f5 = heapClassInst.heapFloat[fp + numDefineNeg182];
                                                        f5 = f5 * f15;
                                                        f3 = f3 + f5;
                                                        f2 = f2 - f3;
                                                        if (!(f2 > f20)) {
                                                            f3 = f12 * f12;
                                                            f5 = f28 + f3;
                                                            heapClassInst.heapFloat[g0] = f5;
                                                            sqrtf(i7);
                                                            f5 = (float) commonVariable.fg0;
                                                            if (f5 > f20) {
                                                                f2 = f2 / f5;
                                                                f25 = (float) numDefineFloat042;
                                                                f25 = f2 * f25;
                                                                if (!(f25 <= f23)) {
                                                                    f22 = 0;
                                                                    f23 = -f12;
                                                                    r11 = f1 < f22 ? 1 : 0;
                                                                    f19 = f4 / f5;
                                                                    f22 = f22 / f5;
                                                                    f24 = f23 / f5;
                                                                    r11 = r11 & 1;
                                                                    r12 = numDefine12;
                                                                    r13 = 0;
                                                                    f23 = f2;
                                                                }
                                                            }
                                                            f1 = f11 * f9;
                                                            f2 = f10 * f13;
                                                            f1 = f1 - f2;
                                                            if (f1 < f27) {
                                                                f2 = -f1;
                                                            } else {
                                                                f2 = f1;
                                                            }
                                                            f4 = heapClassInst.heapFloat[fp + numDefineNeg179];
                                                            f4 = f4 * f15;
                                                            f5 = heapClassInst.heapFloat[fp + numDefineNeg178];
                                                            f5 = f5 * f6;
                                                            f4 = f4 + f5;
                                                            f5 = heapClassInst.heapFloat[fp + numDefineNeg182];
                                                            f5 = f5 * f18;
                                                            f4 = f4 + f5;
                                                            f6 = heapClassInst.heapFloat[fp + numDefineNeg185];
                                                            f5 = heapClassInst.heapFloat[fp + numDefineNeg180];
                                                            f5 = f5 * f6;
                                                            f4 = f4 + f5;
                                                            f2 = f2 - f4;
                                                            if (!(f2 > f20)) {
                                                                f4 = heapClassInst.heapFloat[fp + numDefineNeg188];
                                                                f4 = f4 + f29;
                                                                f4 = f4 + f27;
                                                                heapClassInst.heapFloat[g0] = f4;
                                                                sqrtf(i7);
                                                                f4 = (float) commonVariable.fg0;
                                                                if (f4 > f20) {
                                                                    f2 = f2 / f4;
                                                                    f5 = (float) numDefineFloat042;
                                                                    f5 = f2 * f5;
                                                                    if (!(f5 <= f23)) {
                                                                        f23 = 0;
                                                                        f19 = -f13;
                                                                        r11 = f1 < f23 ? 1 : 0;
                                                                        f19 = f19 / f4;
                                                                        f22 = f9 / f4;
                                                                        f24 = f23 / f4;
                                                                        r11 = r11 & 1;
                                                                        r12 = numDefine13;
                                                                        r13 = 0;
                                                                        f23 = f2;
                                                                    }
                                                                }
                                                                f1 = f11 * f8;
                                                                f2 = f10 * f0;
                                                                f1 = f1 - f2;
                                                                if (f1 < f27) {
                                                                    f2 = -f1;
                                                                } else {
                                                                    f2 = f1;
                                                                }
                                                                f4 = heapClassInst.heapFloat[fp + numDefineNeg179];
                                                                f4 = f4 * f16;
                                                                f5 = heapClassInst.heapFloat[fp + numDefineNeg178];
                                                                f5 = f5 * f7;
                                                                f4 = f4 + f5;
                                                                f5 = heapClassInst.heapFloat[fp + numDefineNeg181];
                                                                f5 = f5 * f18;
                                                                f4 = f4 + f5;
                                                                f6 = heapClassInst.heapFloat[fp + numDefineNeg184];
                                                                f5 = heapClassInst.heapFloat[fp + numDefineNeg180];
                                                                f5 = f5 * f6;
                                                                f4 = f4 + f5;
                                                                f2 = f2 - f4;
                                                                if (!(f2 > f20)) {
                                                                    f4 = heapClassInst.heapFloat[fp + numDefineNeg189];
                                                                    f4 = f4 + f21;
                                                                    f4 = f4 + f27;
                                                                    heapClassInst.heapFloat[g0] = f4;
                                                                    sqrtf(i7);
                                                                    f4 = (float) commonVariable.fg0;
                                                                    if (f4 > f20) {
                                                                        f2 = f2 / f4;
                                                                        f5 = (float) numDefineFloat042;
                                                                        f5 = f2 * f5;
                                                                        if (!(f5 <= f23)) {
                                                                            f23 = 0;
                                                                            f19 = -f0;
                                                                            r11 = f1 < f23 ? 1 : 0;
                                                                            f19 = f19 / f4;
                                                                            f22 = f8 / f4;
                                                                            f24 = f23 / f4;
                                                                            r11 = r11 & 1;
                                                                            r12 = numDefine14;
                                                                            r13 = 0;
                                                                            f23 = f2;
                                                                        }
                                                                    }
                                                                    f0 = f11 * f12;
                                                                    f1 = f10 * f14;
                                                                    f0 = f0 - f1;
                                                                    if (f0 < f27) {
                                                                        f1 = -f0;
                                                                    } else {
                                                                        f1 = f0;
                                                                    }
                                                                    f2 = heapClassInst.heapFloat[fp + numDefineNeg179];
                                                                    f2 = f2 * f17;
                                                                    f5 = heapClassInst.heapFloat[fp + numDefineNeg183];
                                                                    f4 = heapClassInst.heapFloat[fp + numDefineNeg178];
                                                                    f4 = f4 * f5;
                                                                    f2 = f2 + f4;
                                                                    f5 = heapClassInst.heapFloat[fp + numDefineNeg185];
                                                                    f4 = heapClassInst.heapFloat[fp + numDefineNeg181];
                                                                    f4 = f4 * f5;
                                                                    f2 = f2 + f4;
                                                                    f5 = heapClassInst.heapFloat[fp + numDefineNeg184];
                                                                    f4 = heapClassInst.heapFloat[fp + numDefineNeg182];
                                                                    f4 = f4 * f5;
                                                                    f2 = f2 + f4;
                                                                    f1 = f1 - f2;
                                                                    if (!(f1 > f20)) {
                                                                        f2 = heapClassInst.heapFloat[fp + numDefineNeg190];
                                                                        f2 = f2 + f3;
                                                                        f2 = f2 + f27;
                                                                        heapClassInst.heapFloat[g0] = f2;
                                                                        sqrtf(i7);
                                                                        f2 = (float) commonVariable.fg0;
                                                                        if (f2 <= f20) {
                                                                            label = numDefine128;
                                                                        } else {
                                                                            f1 = f1 / f2;
                                                                            heapClassInst.heapFloat[fp + numDefineNeg183] = f1;
                                                                            f3 = (float) numDefineFloat042;
                                                                            f1 = f1 * f3;
                                                                            if (f1 <= f23) {
                                                                                label = numDefine128;
                                                                            } else {
                                                                                f23 = 0;
                                                                                f19 = -f14;
                                                                                r11 = f0 < f23 ? 1 : 0;
                                                                                f19 = f19 / f2;
                                                                                f22 = f12 / f2;
                                                                                f24 = f23 / f2;
                                                                                r11 = r11 & 1;
                                                                                r13 = sp + numDefineNeg704;
                                                                                r12 = numDefine15;
                                                                                label = numDefine132;
                                                                            }
                                                                        }
                                                                        if (label == numDefine128) {
                                                                            if (r12 == 0) {
                                                                                break repeat41;
                                                                            } else {
                                                                                if (r13 != 0) {
                                                                                    r13 = r13 >> numDefine2;
                                                                                    f0 = heapClassInst.heapFloat[r13];
                                                                                    r6 = sp + numDefineNeg704;
                                                                                    heapClassInst.heapFloat[fp + numDefineNeg176] = f0;
                                                                                    f1 = heapClassInst.heapFloat[r13 + numDefine4];
                                                                                    r6 = r6 >> numDefine2;
                                                                                    heapClassInst.heapFloat[r6 + 1] = f1;
                                                                                    f19 = heapClassInst.heapFloat[r13 + numDefine8];
                                                                                    heapClassInst.heapFloat[r6 + numDefine2] = f19;
                                                                                    heapClassInst.heapFloat[fp + numDefineNeg183] = f23;
                                                                                    label = numDefine133;
                                                                                } else {
                                                                                    r13 = sp + numDefineNeg704;
                                                                                    heapClassInst.heapFloat[fp + numDefineNeg183] = f23;
                                                                                    label = numDefine132;
                                                                                }
                                                                            }
                                                                        }
                                                                        if (label == numDefine132) {
                                                                            r6 = sp + numDefineNeg640;
                                                                            r6 = r6 >> numDefine2;
                                                                            f0 = heapClassInst.heapFloat[fp + numDefineNeg160];
                                                                            f1 = heapClassInst.heapFloat[r6 + 1];
                                                                            f2 = heapClassInst.heapFloat[r6 + numDefine2];
                                                                            f0 = f0 * f19;
                                                                            f1 = f1 * f22;
                                                                            f0 = f0 + f1;
                                                                            f1 = f2 * f24;
                                                                            f0 = f0 + f1;
                                                                            r7 = r13 >> numDefine2;
                                                                            heapClassInst.heapFloat[r7] = f0;
                                                                            f1 = heapClassInst.heapFloat[r6 + numDefine4];
                                                                            f2 = heapClassInst.heapFloat[r6 + numDefine5];
                                                                            f3 = heapClassInst.heapFloat[r6 + numDefine6];
                                                                            f1 = f1 * f19;
                                                                            f2 = f2 * f22;
                                                                            r7 = sp + numDefineNeg704;
                                                                            f1 = f1 + f2;
                                                                            f2 = f3 * f24;
                                                                            f1 = f1 + f2;
                                                                            r7 = r7 >> numDefine2;
                                                                            heapClassInst.heapFloat[r7 + 1] = f1;
                                                                            f2 = heapClassInst.heapFloat[r6 + numDefine8];
                                                                            f3 = heapClassInst.heapFloat[r6 + numDefine9];
                                                                            f4 = heapClassInst.heapFloat[r6 + numDefine10];
                                                                            f19 = f2 * f19;
                                                                            f2 = f3 * f22;
                                                                            f19 = f19 + f2;
                                                                            f2 = f4 * f24;
                                                                            f19 = f19 + f2;
                                                                            heapClassInst.heapFloat[r7 + numDefine2] = f19;
                                                                        }
                                                                        if (r11 != 0) {
                                                                            f0 = -f0;
                                                                            r6 = sp + numDefineNeg704;
                                                                            f1 = -f1;
                                                                            r6 = r6 >> numDefine2;
                                                                            heapClassInst.heapFloat[fp + numDefineNeg176] = f0;
                                                                            f19 = -f19;
                                                                            heapClassInst.heapFloat[r6 + 1] = f1;
                                                                            heapClassInst.heapFloat[r6 + numDefine2] = f19;
                                                                        }
                                                                        if (r12 < numDefine7) {
                                                                            if (r12 > numDefine3) {
                                                                                f0 = -f0;
                                                                                f1 = -f1;
                                                                                f19 = -f19;
                                                                                r1 = r0;
                                                                                r0 = r10;
                                                                            } else {
                                                                                r3 = sp + numDefineNeg640;
                                                                                r2 = sp + numDefineNeg688;
                                                                                r4 = sp + numDefineNeg236;
                                                                                heapClassInst.heap32[fp + numDefineNeg186] = r4;
                                                                                r4 = sp + numDefineNeg248;
                                                                                r1 = r10;
                                                                            }
                                                                            r6 = r2 >> numDefine2;
                                                                            f2 = heapClassInst.heapFloat[r6];
                                                                            f3 = heapClassInst.heapFloat[r6 + numDefine4];
                                                                            f4 = heapClassInst.heapFloat[r6 + numDefine8];
                                                                            f2 = f2 * f0;
                                                                            f3 = f3 * f1;
                                                                            f2 = f2 + f3;
                                                                            f3 = f4 * f19;
                                                                            f2 = f2 + f3;
                                                                            heapClassInst.heapFloat[fp + numDefineNeg66] = f2;
                                                                            f3 = heapClassInst.heapFloat[r6 + 1];
                                                                            f4 = heapClassInst.heapFloat[r6 + numDefine5];
                                                                            f5 = heapClassInst.heapFloat[r6 + numDefine9];
                                                                            f3 = f3 * f0;
                                                                            f4 = f4 * f1;
                                                                            r7 = sp + numDefineNeg264;
                                                                            f3 = f3 + f4;
                                                                            f4 = f5 * f19;
                                                                            f3 = f3 + f4;
                                                                            r8 = r7 >> numDefine2;
                                                                            heapClassInst.heapFloat[r8 + 1] = f3;
                                                                            f4 = heapClassInst.heapFloat[r6 + numDefine2];
                                                                            f5 = heapClassInst.heapFloat[r6 + numDefine6];
                                                                            f6 = heapClassInst.heapFloat[r6 + numDefine10];
                                                                            f4 = f4 * f0;
                                                                            f5 = f5 * f1;
                                                                            f4 = f4 + f5;
                                                                            f5 = f6 * f19;
                                                                            f4 = f4 + f5;
                                                                            heapClassInst.heapFloat[r8 + numDefine2] = f4;
                                                                            if (f2 < f27) {
                                                                                f2 = -f2;
                                                                            }
                                                                            if (f3 < f27) {
                                                                                f3 = -f3;
                                                                            }
                                                                            if (f4 < f27) {
                                                                                f4 = -f4;
                                                                            }
                                                                            if (f3 <= f2) {
                                                                                if (f2 <= f4) {
                                                                                    r6 = numDefine2;
                                                                                    r8 = 0;
                                                                                    r9 = 1;
                                                                                } else {
                                                                                    r6 = 0;
                                                                                    r8 = 1;
                                                                                    r9 = numDefine2;
                                                                                }
                                                                            } else {
                                                                                if (f3 <= f4) {
                                                                                    r6 = numDefine2;
                                                                                    r8 = 0;
                                                                                    r9 = 1;
                                                                                } else {
                                                                                    r6 = 1;
                                                                                    r8 = 0;
                                                                                    r9 = numDefine2;
                                                                                }
                                                                            }
                                                                            r10 = r6 << numDefine2;
                                                                            r11 = (r4 + r10) | 0;
                                                                            r13 = (r2 + r10) | 0;
                                                                            r1 = r1 >> numDefine2;
                                                                            r0 = r0 >> numDefine2;
                                                                            r11 = r11 >> numDefine2;
                                                                            r13 = r13 >> numDefine2;
                                                                            f2 = heapClassInst.heapFloat[r11];
                                                                            f3 = heapClassInst.heapFloat[r13];
                                                                            f4 = heapClassInst.heapFloat[r1];
                                                                            f5 = heapClassInst.heapFloat[r0];
                                                                            r7 = (r7 + r10) | 0;
                                                                            f4 = f4 - f5;
                                                                            f3 = f2 * f3;
                                                                            r7 = r7 >> numDefine2;
                                                                            f5 = heapClassInst.heapFloat[r7];
                                                                            if (f5 < f27) {
                                                                                r7 = r6 | numDefine4;
                                                                                r6 = r6 | numDefine8;
                                                                                r7 = r7 << numDefine2;
                                                                                r6 = r6 << numDefine2;
                                                                                r7 = (r2 + r7) | 0;
                                                                                r6 = (r2 + r6) | 0;
                                                                                r7 = r7 >> numDefine2;
                                                                                r6 = r6 >> numDefine2;
                                                                                f5 = heapClassInst.heapFloat[r1 + 1];
                                                                                f6 = heapClassInst.heapFloat[r0 + 1];
                                                                                f7 = heapClassInst.heapFloat[r7];
                                                                                f8 = heapClassInst.heapFloat[r6];
                                                                                f9 = heapClassInst.heapFloat[r1 + numDefine2];
                                                                                f10 = heapClassInst.heapFloat[r0 + numDefine2];
                                                                                f5 = f5 - f6;
                                                                                f6 = f2 * f7;
                                                                                f7 = f9 - f10;
                                                                                f2 = f2 * f8;
                                                                                f3 = f4 + f3;
                                                                                f4 = f5 + f6;
                                                                                f2 = f7 + f2;
                                                                            } else {
                                                                                r7 = r6 | numDefine4;
                                                                                r6 = r6 | numDefine8;
                                                                                r7 = r7 << numDefine2;
                                                                                r6 = r6 << numDefine2;
                                                                                r7 = (r2 + r7) | 0;
                                                                                r6 = (r2 + r6) | 0;
                                                                                r7 = r7 >> numDefine2;
                                                                                r6 = r6 >> numDefine2;
                                                                                f5 = heapClassInst.heapFloat[r1 + 1];
                                                                                f6 = heapClassInst.heapFloat[r0 + 1];
                                                                                f7 = heapClassInst.heapFloat[r7];
                                                                                f8 = heapClassInst.heapFloat[r6];
                                                                                f9 = heapClassInst.heapFloat[r1 + numDefine2];
                                                                                f10 = heapClassInst.heapFloat[r0 + numDefine2];
                                                                                f5 = f5 - f6;
                                                                                f6 = f2 * f7;
                                                                                f7 = f9 - f10;
                                                                                f2 = f2 * f8;
                                                                                f3 = f4 - f3;
                                                                                f4 = f5 - f6;
                                                                                f2 = f7 - f2;
                                                                            }
                                                                            r1 = -1;
                                                                            r6 = numDefineNeg4;
                                                                            r6 = r12 < numDefine4 ? r1 : r6;
                                                                            r6 = (r6 + r12) | 0;
                                                                            if (r6 == 1) {
                                                                                r7 = 0;
                                                                                r10 = numDefine2;
                                                                            } else {
                                                                                if (r6 != 0) {
                                                                                    r7 = 0;
                                                                                    r10 = 1;
                                                                                } else {
                                                                                    r7 = 1;
                                                                                    r10 = numDefine2;
                                                                                }
                                                                            }
                                                                            r11 = r8 | numDefine4;
                                                                            r13 = r7 | numDefine4;
                                                                            r14 = r8 | numDefine8;
                                                                            r15 = r9 | numDefine4;
                                                                            r16 = r7 | numDefine8;
                                                                            r17 = r10 | numDefine4;
                                                                            r7 = r7 << numDefine2;
                                                                            r13 = r13 << numDefine2;
                                                                            r11 = r11 << numDefine2;
                                                                            r8 = r8 << numDefine2;
                                                                            r18 = r9 | numDefine8;
                                                                            r19 = (r3 + r7) | 0;
                                                                            r13 = (r3 + r13) | 0;
                                                                            r16 = r16 << numDefine2;
                                                                            r20 = r10 << numDefine2;
                                                                            r17 = r17 << numDefine2;
                                                                            r10 = r10 | numDefine8;
                                                                            r21 = (r2 + r8) | 0;
                                                                            r11 = (r2 + r11) | 0;
                                                                            r14 = r14 << numDefine2;
                                                                            r15 = r15 << numDefine2;
                                                                            r9 = r9 << numDefine2;
                                                                            r19 = r19 >> numDefine2;
                                                                            r13 = r13 >> numDefine2;
                                                                            r16 = (r3 + r16) | 0;
                                                                            r22 = (r3 + r20) | 0;
                                                                            r17 = (r3 + r17) | 0;
                                                                            r10 = r10 << numDefine2;
                                                                            r21 = r21 >> numDefine2;
                                                                            heapClassInst.heap32[fp + numDefineNeg178] = r21;
                                                                            r11 = r11 >> numDefine2;
                                                                            heapClassInst.heap32[fp + numDefineNeg177] = r11;
                                                                            r14 = (r2 + r14) | 0;
                                                                            r23 = (r2 + r9) | 0;
                                                                            r15 = (r2 + r15) | 0;
                                                                            r18 = r18 << numDefine2;
                                                                            r16 = r16 >> numDefine2;
                                                                            r22 = r22 >> numDefine2;
                                                                            r17 = r17 >> numDefine2;
                                                                            r3 = (r3 + r10) | 0;
                                                                            r10 = r14 >> numDefine2;
                                                                            heapClassInst.heap32[fp + numDefineNeg179] = r10;
                                                                            r14 = r23 >> numDefine2;
                                                                            heapClassInst.heap32[fp + numDefineNeg180] = r14;
                                                                            r15 = r15 >> numDefine2;
                                                                            r2 = (r2 + r18) | 0;
                                                                            f5 = heapClassInst.heapFloat[r19];
                                                                            f6 = heapClassInst.heapFloat[r21];
                                                                            f7 = heapClassInst.heapFloat[r13];
                                                                            f8 = heapClassInst.heapFloat[r11];
                                                                            f9 = heapClassInst.heapFloat[r22];
                                                                            f10 = heapClassInst.heapFloat[r14];
                                                                            f11 = heapClassInst.heapFloat[r17];
                                                                            f12 = heapClassInst.heapFloat[r15];
                                                                            r3 = r3 >> numDefine2;
                                                                            r2 = r2 >> numDefine2;
                                                                            r8 = (r4 + r8) | 0;
                                                                            f13 = f5 * f6;
                                                                            f14 = f7 * f8;
                                                                            f15 = heapClassInst.heapFloat[r16];
                                                                            f16 = heapClassInst.heapFloat[r10];
                                                                            f17 = heapClassInst.heapFloat[r3];
                                                                            f18 = heapClassInst.heapFloat[r2];
                                                                            r3 = r8 >> numDefine2;
                                                                            r4 = (r4 + r9) | 0;
                                                                            f6 = f9 * f6;
                                                                            f8 = f11 * f8;
                                                                            f21 = f3 * f5;
                                                                            f22 = f4 * f7;
                                                                            f13 = f13 + f14;
                                                                            f14 = f15 * f16;
                                                                            f5 = f5 * f10;
                                                                            f7 = f7 * f12;
                                                                            f13 = f13 + f14;
                                                                            f14 = heapClassInst.heapFloat[r3];
                                                                            r3 = r4 >> numDefine2;
                                                                            f23 = f3 * f9;
                                                                            f24 = f4 * f11;
                                                                            f6 = f6 + f8;
                                                                            f8 = f17 * f16;
                                                                            f9 = f9 * f10;
                                                                            f10 = f11 * f12;
                                                                            f11 = f21 + f22;
                                                                            f12 = f2 * f15;
                                                                            f5 = f5 + f7;
                                                                            f7 = f15 * f18;
                                                                            f6 = f6 + f8;
                                                                            f8 = f11 + f12;
                                                                            f11 = f14 * f13;
                                                                            f5 = f5 + f7;
                                                                            f7 = heapClassInst.heapFloat[r3];
                                                                            f12 = f23 + f24;
                                                                            f15 = f2 * f17;
                                                                            f9 = f9 + f10;
                                                                            f10 = f17 * f18;
                                                                            f9 = f9 + f10;
                                                                            f10 = f12 + f15;
                                                                            f12 = f14 * f6;
                                                                            f14 = f8 - f11;
                                                                            f15 = f7 * f5;
                                                                            r3 = sp + numDefineNeg296;
                                                                            f16 = f10 - f12;
                                                                            f7 = f7 * f9;
                                                                            f17 = f14 - f15;
                                                                            r4 = r3 >> numDefine2;
                                                                            f18 = f16 - f7;
                                                                            heapClassInst.heapFloat[fp + numDefineNeg74] = f17;
                                                                            f14 = f14 + f15;
                                                                            heapClassInst.heapFloat[r4 + 1] = f18;
                                                                            f11 = f8 + f11;
                                                                            f16 = f16 + f7;
                                                                            heapClassInst.heapFloat[r4 + numDefine2] = f14;
                                                                            f12 = f10 + f12;
                                                                            f14 = f11 + f15;
                                                                            heapClassInst.heapFloat[r4 + numDefine3] = f16;
                                                                            f16 = f12 + f7;
                                                                            heapClassInst.heapFloat[r4 + numDefine4] = f14;
                                                                            f11 = f11 - f15;
                                                                            heapClassInst.heapFloat[r4 + numDefine5] = f16;
                                                                            r8 = heapClassInst.heap32[fp + numDefineNeg186];
                                                                            r7 = (r8 + r7) | 0;
                                                                            f7 = f12 - f7;
                                                                            heapClassInst.heapFloat[r4 + numDefine6] = f11;
                                                                            r9 = sp + numDefineNeg304;
                                                                            r8 = (r8 + r20) | 0;
                                                                            r7 = r7 >> numDefine2;
                                                                            heapClassInst.heapFloat[r4 + numDefine7] = f7;
                                                                            r4 = sp + numDefineNeg368;
                                                                            r10 = 0;
                                                                            r11 = numDefine4;
                                                                            r13 = r9 >> numDefine2;
                                                                            r8 = r8 >> numDefine2;
                                                                            heapClassInst.heap32[fp + numDefineNeg76] = heapClassInst.heap32[r7];
                                                                            heapClassInst.heap32[r13 + 1] = heapClassInst.heap32[r8];
                                                                            r7 = r10;
                                                                            repeat217:
                                                                            while (true) {
                                                                                if (r7 < numDefine2) {
                                                                                    r18 = 0;
                                                                                    r17 = (r18 - r7) | 0;
                                                                                    r14 = r1;
                                                                                    r8 = r4;
                                                                                    repeat220:
                                                                                    while (true) {
                                                                                        r4 = r8;
                                                                                        if (r14 > 1) {
                                                                                            break repeat220;
                                                                                        } else {
                                                                                            f7 = r14;
                                                                                            r16 = (r3 + numDefine8) | 0;
                                                                                            r8 = r18;
                                                                                            r10 = r18;
                                                                                            r13 = r4;
                                                                                            repeat223:
                                                                                            while (true) {
                                                                                                if (r11 > 0) {
                                                                                                    r19 = (r3 + r8) | 0;
                                                                                                    r20 = (r16 + r8) | 0;
                                                                                                    r21 = r7 << numDefine2;
                                                                                                    r22 = (r9 + r21) | 0;
                                                                                                    r23 = (r19 + r21) | 0;
                                                                                                    r22 = r22 >> numDefine2;
                                                                                                    r23 = r23 >> numDefine2;
                                                                                                    f11 = heapClassInst.heapFloat[r22];
                                                                                                    f12 = heapClassInst.heapFloat[r23];
                                                                                                    f14 = f7 * f12;
                                                                                                    if (f14 < f11) {
                                                                                                        r24 = r13 >> numDefine2;
                                                                                                        r25 = r19 >> numDefine2;
                                                                                                        r10 = (r10 + 1) | 0;
                                                                                                        heapClassInst.heap32[r24] = heapClassInst.heap32[r25];
                                                                                                        heapClassInst.heap32[r24 + 1] = heapClassInst.heap32[r25 + 1];
                                                                                                        r24 = r10 & numDefine8;
                                                                                                        if (r24 == 0) {
                                                                                                            r13 = (r13 + numDefine8) | 0;
                                                                                                            f12 = heapClassInst.heapFloat[r23];
                                                                                                            f11 = heapClassInst.heapFloat[r22];
                                                                                                        } else {
                                                                                                            label = numDefine179;
                                                                                                            break repeat217;
                                                                                                        }
                                                                                                    }
                                                                                                    r20 = r11 > 1 ? r20 : r3;
                                                                                                    r23 = (r20 + r21) | 0;
                                                                                                    r23 = r23 >> numDefine2;
                                                                                                    f14 = heapClassInst.heapFloat[r23];
                                                                                                    f15 = f7 * f12;
                                                                                                    f16 = f7 * f14;
                                                                                                    r23 = f15 < f11 ? 1 : 0;
                                                                                                    r24 = f16 < f11 ? 1 : 0;
                                                                                                    r23 = r23 ^ r24;
                                                                                                    if (r23 != 0) {
                                                                                                        r23 = r17 << numDefine2;
                                                                                                        r19 = (r19 + r23) | 0;
                                                                                                        r20 = (r20 + r23) | 0;
                                                                                                        r19 = r19 >> numDefine2;
                                                                                                        r20 = r20 >> numDefine2;
                                                                                                        f15 = heapClassInst.heapFloat[r19 + 1];
                                                                                                        f16 = heapClassInst.heapFloat[r20 + 1];
                                                                                                        f11 = f7 * f11;
                                                                                                        f16 = f16 - f15;
                                                                                                        f14 = f14 - f12;
                                                                                                        f14 = f16 / f14;
                                                                                                        f11 = f11 - f12;
                                                                                                        r19 = (r13 + r23) | 0;
                                                                                                        f11 = f14 * f11;
                                                                                                        r19 = r19 >> numDefine2;
                                                                                                        f11 = f15 + f11;
                                                                                                        heapClassInst.heapFloat[r19 + 1] = f11;
                                                                                                        r19 = (r13 + r21) | 0;
                                                                                                        f11 = heapClassInst.heapFloat[r22];
                                                                                                        r10 = (r10 + 1) | 0;
                                                                                                        r19 = r19 >> numDefine2;
                                                                                                        f11 = f7 * f11;
                                                                                                        heapClassInst.heapFloat[r19] = f11;
                                                                                                        r19 = r10 & numDefine8;
                                                                                                        if (r19 == 0) {
                                                                                                            r13 = (r13 + numDefine8) | 0;
                                                                                                        } else {
                                                                                                            label = numDefine179;
                                                                                                            break repeat217;
                                                                                                        }
                                                                                                    }
                                                                                                    r11 = (r11 + -1) | 0;
                                                                                                    r8 = (r8 + numDefine8) | 0;
                                                                                                } else {
                                                                                                    break repeat223;
                                                                                                }
                                                                                            }
                                                                                            r3 = sp + numDefineNeg368;
                                                                                            r8 = sp + numDefineNeg128;
                                                                                            r8 = r4 == r3 ? r8 : r3;
                                                                                            r14 = (r14 + numDefine2) | 0;
                                                                                            r3 = r4;
                                                                                            r11 = r10;
                                                                                        }
                                                                                    }
                                                                                    r7 = (r7 + 1) | 0;
                                                                                } else {
                                                                                    label = numDefine177;
                                                                                    break repeat217;
                                                                                }
                                                                            }
                                                                            if (label == numDefine177) {
                                                                                r4 = r3;
                                                                            }
                                                                            r1 = sp + numDefineNeg368;
                                                                            if (!(r4 == r1)) {
                                                                                r3 = r10 << numDefine3;
                                                                                heapClassInst.heap32[g0] = r1;
                                                                                heapClassInst.heap32[g0 + 1] = r4;
                                                                                heapClassInst.heap32[g0 + numDefine2] = r3;
                                                                                memcpy(i7);
                                                                            }
                                                                            if (r10 < 1) {
                                                                                break repeat41;
                                                                            } else {
                                                                                f7 = f13 * f9;
                                                                                f11 = f5 * f6;
                                                                                f12 = 1;
                                                                                f7 = f7 - f11;
                                                                                r3 = r6 << numDefine2;
                                                                                f7 = f12 / f7;
                                                                                r4 = heapClassInst.heap32[fp + numDefineNeg186];
                                                                                r3 = (r4 + r3) | 0;
                                                                                f6 = f6 * f7;
                                                                                r3 = r3 >> numDefine2;
                                                                                f11 = f13 * f7;
                                                                                f5 = f5 * f7;
                                                                                f7 = f9 * f7;
                                                                                f6 = -f6;
                                                                                f9 = heapClassInst.heapFloat[r3];
                                                                                r3 = heapClassInst.heap32[fp + numDefineNeg178];
                                                                                f13 = heapClassInst.heapFloat[r3];
                                                                                r3 = heapClassInst.heap32[fp + numDefineNeg180];
                                                                                f14 = heapClassInst.heapFloat[r3];
                                                                                r3 = heapClassInst.heap32[fp + numDefineNeg177];
                                                                                f15 = heapClassInst.heapFloat[r3];
                                                                                f16 = heapClassInst.heapFloat[r15];
                                                                                r3 = heapClassInst.heap32[fp + numDefineNeg179];
                                                                                f17 = heapClassInst.heapFloat[r3];
                                                                                f18 = heapClassInst.heapFloat[r2];
                                                                                r2 = (r1 + numDefine4) | 0;
                                                                                r3 = 0;
                                                                                repeat243:
                                                                                while (true) {
                                                                                    r4 = r2 >> numDefine2;
                                                                                    f21 = heapClassInst.heapFloat[r4 + -1];
                                                                                    f22 = heapClassInst.heapFloat[r4];
                                                                                    f23 = f21 - f8;
                                                                                    f24 = f22 - f10;
                                                                                    f25 = f23 * f7;
                                                                                    f26 = f24 * f5;
                                                                                    f25 = f25 - f26;
                                                                                    f23 = f23 * f6;
                                                                                    f24 = f24 * f11;
                                                                                    r4 = (r3 * numDefine3) | 0;
                                                                                    f26 = f15 * f25;
                                                                                    f23 = f23 + f24;
                                                                                    f24 = f13 * f25;
                                                                                    r6 = sp + numDefineNeg464;
                                                                                    r4 = r4 << numDefine2;
                                                                                    f25 = f17 * f25;
                                                                                    f26 = f4 + f26;
                                                                                    f28 = f16 * f23;
                                                                                    f24 = f3 + f24;
                                                                                    f29 = f14 * f23;
                                                                                    r4 = (r6 + r4) | 0;
                                                                                    f24 = f24 + f29;
                                                                                    f26 = f26 + f28;
                                                                                    f25 = f2 + f25;
                                                                                    f23 = f18 * f23;
                                                                                    f28 = f0 * f24;
                                                                                    f29 = f1 * f26;
                                                                                    f23 = f25 + f23;
                                                                                    r4 = r4 >> numDefine2;
                                                                                    heapClassInst.heapFloat[r4] = f24;
                                                                                    f24 = f28 + f29;
                                                                                    f25 = f19 * f23;
                                                                                    r7 = sp + numDefineNeg496;
                                                                                    r8 = r3 << numDefine2;
                                                                                    r8 = (r7 + r8) | 0;
                                                                                    heapClassInst.heapFloat[r4 + 1] = f26;
                                                                                    f24 = f24 + f25;
                                                                                    f24 = f9 - f24;
                                                                                    r8 = r8 >> numDefine2;
                                                                                    heapClassInst.heapFloat[r4 + numDefine2] = f23;
                                                                                    heapClassInst.heapFloat[r8] = f24;
                                                                                    if (f24 >= f27) {
                                                                                        r4 = r3 << numDefine3;
                                                                                        r8 = r4 | numDefine4;
                                                                                        r4 = (r1 + r4) | 0;
                                                                                        r8 = (r1 + r8) | 0;
                                                                                        r4 = r4 >> numDefine2;
                                                                                        r3 = (r3 + 1) | 0;
                                                                                        r8 = r8 >> numDefine2;
                                                                                        heapClassInst.heapFloat[r4] = f21;
                                                                                        heapClassInst.heapFloat[r8] = f22;
                                                                                    }
                                                                                    r10 = (r10 + -1) | 0;
                                                                                    r2 = (r2 + numDefine8) | 0;
                                                                                    if (!(r10 != 0)) {
                                                                                        break repeat243;
                                                                                    }
                                                                                }
                                                                                if (r3 < 1) {
                                                                                    break repeat41;
                                                                                } else {
                                                                                    r2 = numDefine4;
                                                                                    r2 = r3 < numDefine4 ? r3 : r2;
                                                                                    r4 = 1;
                                                                                    r8 = r2 < 1 ? r4 : r2;
                                                                                    if (r3 > r8) {
                                                                                        repeat252:
                                                                                        do {
                                                                                            if (r3 > 1) {
                                                                                                f0 = heapClassInst.heapFloat[fp + numDefineNeg124];
                                                                                                r9 = 1;
                                                                                                r7 = 0;
                                                                                                while (true) {
                                                                                                    r10 = sp + numDefineNeg496;
                                                                                                    r11 = r9 << numDefine2;
                                                                                                    r10 = (r10 + r11) | 0;
                                                                                                    r10 = r10 >> numDefine2;
                                                                                                    f1 = heapClassInst.heapFloat[r10];
                                                                                                    r10 = (r9 + 1) | 0;
                                                                                                    r7 = f1 > f0 ? r9 : r7;
                                                                                                    f0 = f1 > f0 ? f1 : f0;
                                                                                                    r9 = r10;
                                                                                                    if (!(r3 != r10)) {
                                                                                                        break repeat252;
                                                                                                    }
                                                                                                }
                                                                                            } else {
                                                                                                r7 = 0;
                                                                                            }
                                                                                        } while (false);
                                                                                        repeat258:
                                                                                        do {
                                                                                            if (r3 == 1) {
                                                                                                r9 = r1 >> numDefine2;
                                                                                                f0 = heapClassInst.heapFloat[fp + numDefineNeg92];
                                                                                                f1 = heapClassInst.heapFloat[r9 + 1];
                                                                                                label = numDefine214;
                                                                                                break repeat258;
                                                                                            } else {
                                                                                                if (r3 == numDefine2) {
                                                                                                    r9 = r1 >> numDefine2;
                                                                                                    f0 = heapClassInst.heapFloat[fp + numDefineNeg92];
                                                                                                    f1 = heapClassInst.heapFloat[r9 + numDefine2];
                                                                                                    f2 = heapClassInst.heapFloat[r9 + 1];
                                                                                                    f12 = heapClassInst.heapFloat[r9 + numDefine3];
                                                                                                    f0 = f0 + f1;
                                                                                                    f1 = f2 + f12;
                                                                                                    f2 = heapClassInst.heapFloat[fp + numDefineNeg187];
                                                                                                    f0 = f0 * f2;
                                                                                                    f1 = f1 * f2;
                                                                                                    label = numDefine214;
                                                                                                    break repeat258;
                                                                                                } else {
                                                                                                    r9 = (r3 + -1) | 0;
                                                                                                    repeat264:
                                                                                                    do {
                                                                                                        if (r9 > 0) {
                                                                                                            r10 = (r1 + numDefine8) | 0;
                                                                                                            f0 = 0;
                                                                                                            f1 = f0;
                                                                                                            f2 = f0;
                                                                                                            while (true) {
                                                                                                                r11 = r10 >> numDefine2;
                                                                                                                f3 = heapClassInst.heapFloat[r11 + numDefineNeg2];
                                                                                                                f4 = heapClassInst.heapFloat[r11 + 1];
                                                                                                                f5 = heapClassInst.heapFloat[r11];
                                                                                                                f6 = heapClassInst.heapFloat[r11 + -1];
                                                                                                                f7 = f3 * f4;
                                                                                                                f8 = f5 * f6;
                                                                                                                f3 = f3 + f5;
                                                                                                                f5 = f7 - f8;
                                                                                                                f4 = f6 + f4;
                                                                                                                f3 = f3 * f5;
                                                                                                                f4 = f4 * f5;
                                                                                                                r9 = (r9 + -1) | 0;
                                                                                                                f2 = f2 + f5;
                                                                                                                f1 = f3 + f1;
                                                                                                                f0 = f4 + f0;
                                                                                                                r10 = (r10 + numDefine8) | 0;
                                                                                                                if (!(r9 != 0)) {
                                                                                                                    break repeat264;
                                                                                                                }
                                                                                                            }
                                                                                                        } else {
                                                                                                            f0 = f27;
                                                                                                            f1 = f27;
                                                                                                            f2 = f27;
                                                                                                        }
                                                                                                    } while (false);
                                                                                                    r9 = r3 << numDefine3;
                                                                                                    r9 = (r9 + r1) | 0;
                                                                                                    r9 = r9 >> numDefine2;
                                                                                                    r10 = r1 >> numDefine2;
                                                                                                    f3 = heapClassInst.heapFloat[r9 + numDefineNeg2];
                                                                                                    f4 = heapClassInst.heapFloat[r10 + 1];
                                                                                                    f5 = heapClassInst.heapFloat[fp + numDefineNeg92];
                                                                                                    f6 = heapClassInst.heapFloat[r9 + -1];
                                                                                                    f7 = f3 * f4;
                                                                                                    f8 = f5 * f6;
                                                                                                    f7 = f7 - f8;
                                                                                                    f2 = f2 + f7;
                                                                                                    if (f2 < f27) {
                                                                                                        f8 = -f2;
                                                                                                    } else {
                                                                                                        f8 = f2;
                                                                                                    }
                                                                                                    if (f8 > f20) {
                                                                                                        f8 = numDefine3;
                                                                                                        f2 = f2 * f8;
                                                                                                        f2 = f12 / f2;
                                                                                                    } else {
                                                                                                        f2 = numDefine49440;
                                                                                                    }
                                                                                                    if (r3 > 0) {
                                                                                                        f3 = f3 + f5;
                                                                                                        f4 = f6 + f4;
                                                                                                        f3 = f3 * f7;
                                                                                                        f4 = f4 * f7;
                                                                                                        f1 = f3 + f1;
                                                                                                        f3 = f4 + f0;
                                                                                                        f0 = f1 * f2;
                                                                                                        f1 = f3 * f2;
                                                                                                        label = numDefine214;
                                                                                                    } else {
                                                                                                        r1 = 0;
                                                                                                        label = numDefine219;
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        } while (false);
                                                                                        if (label == numDefine214) {
                                                                                            r1 = (r1 + numDefine4) | 0;
                                                                                            r9 = sp + numDefineNeg32;
                                                                                            r10 = r3;
                                                                                            repeat283:
                                                                                            while (true) {
                                                                                                r11 = r1 >> numDefine2;
                                                                                                f2 = heapClassInst.heapFloat[r11 + -1];
                                                                                                f3 = heapClassInst.heapFloat[r11];
                                                                                                f3 = f3 - f1;
                                                                                                f2 = f2 - f0;
                                                                                                heapClassInst.heapFloat[g0] = f3;
                                                                                                heapClassInst.heapFloat[g0 + 1] = f2;
                                                                                                r10 = (r10 + -1) | 0;
                                                                                                r1 = (r1 + numDefine8) | 0;
                                                                                                r11 = (r9 + numDefine4) | 0;
                                                                                                r9 = r9 >> numDefine2;
                                                                                                atan2f(i7);
                                                                                                heapClassInst.heapFloat[r9] = (float) commonVariable.fg0;
                                                                                                r9 = r11;
                                                                                                if (!(r10 != 0)) {
                                                                                                    break repeat283;
                                                                                                }
                                                                                            }
                                                                                            r1 = sp + numDefineNeg64;
                                                                                            r9 = r3;
                                                                                            repeat286:
                                                                                            while (true) {
                                                                                                r9 = (r9 + -1) | 0;
                                                                                                r10 = (r1 + numDefine4) | 0;
                                                                                                r1 = r1 >> numDefine2;
                                                                                                heapClassInst.heap32[r1] = 1;
                                                                                                r1 = r10;
                                                                                                if (!(r9 != 0)) {
                                                                                                    break repeat286;
                                                                                                }
                                                                                            }
                                                                                            r1 = 1;
                                                                                        }
                                                                                        r9 = sp + numDefineNeg64;
                                                                                        r10 = r7 << numDefine2;
                                                                                        r11 = (r9 + r10) | 0;
                                                                                        r11 = r11 >> numDefine2;
                                                                                        f0 = (float) numDefineFloat265;
                                                                                        f1 = r8;
                                                                                        f1 = f0 / f1;
                                                                                        heapClassInst.heap32[r11] = 0;
                                                                                        heapClassInst.heap32[fp + numDefineNeg144] = r7;
                                                                                        f6 = 0;
                                                                                        repeat290:
                                                                                        while (true) {
                                                                                            if (r4 < r8) {
                                                                                                r11 = sp + numDefineNeg32;
                                                                                                r13 = (r11 + r10) | 0;
                                                                                                r13 = r13 >> numDefine2;
                                                                                                f2 = r4;
                                                                                                f2 = f2 * f1;
                                                                                                f3 = heapClassInst.heapFloat[r13];
                                                                                                f2 = f2 + f3;
                                                                                                f3 = (float) numDefineFloat132;
                                                                                                if (f2 > f3) {
                                                                                                    f4 = (float) numDefineNegFloat265;
                                                                                                    f2 = f2 + f4;
                                                                                                }
                                                                                                r13 = sp + numDefineNeg576;
                                                                                                r14 = r4 << numDefine2;
                                                                                                r13 = (r13 + r14) | 0;
                                                                                                r13 = r13 >> numDefine2;
                                                                                                r14 = r1 & 1;
                                                                                                heapClassInst.heap32[r13] = r7;
                                                                                                if (r14 == 0) {
                                                                                                    label = numDefine233;
                                                                                                    break repeat290;
                                                                                                } else {
                                                                                                    f4 = numDefineN9;
                                                                                                    r14 = 0;
                                                                                                    r15 = r7;
                                                                                                    repeat297:
                                                                                                    while (true) {
                                                                                                        r16 = r14 << numDefine2;
                                                                                                        r17 = (r9 + r16) | 0;
                                                                                                        r17 = r17 >> numDefine2;
                                                                                                        r17 = heapClassInst.heap32[r17];
                                                                                                        if (r17 != 0) {
                                                                                                            r16 = (r11 + r16) | 0;
                                                                                                            r16 = r16 >> numDefine2;
                                                                                                            f5 = heapClassInst.heapFloat[r16];
                                                                                                            f5 = f5 - f2;
                                                                                                            if (f5 < f6) {
                                                                                                                f5 = -f5;
                                                                                                            }
                                                                                                            if (f5 > f3) {
                                                                                                                f5 = f0 - f5;
                                                                                                            }
                                                                                                            if (!(f5 >= f4)) {
                                                                                                                heapClassInst.heap32[r13] = r14;
                                                                                                                r15 = r14;
                                                                                                                f4 = f5;
                                                                                                            }
                                                                                                        }
                                                                                                        r14 = (r14 + 1) | 0;
                                                                                                        if (!(r3 != r14)) {
                                                                                                            break repeat297;
                                                                                                        }
                                                                                                    }
                                                                                                    if (r15 != r7) {
                                                                                                        r11 = r15 << numDefine2;
                                                                                                        r11 = (r9 + r11) | 0;
                                                                                                        r4 = (r4 + 1) | 0;
                                                                                                        r11 = r11 >> numDefine2;
                                                                                                        heapClassInst.heap32[r11] = 0;
                                                                                                    } else {
                                                                                                        label = numDefine233;
                                                                                                        break repeat290;
                                                                                                    }
                                                                                                }
                                                                                            } else {
                                                                                                label = numDefine236;
                                                                                                break repeat290;
                                                                                            }
                                                                                        }
                                                                                        switch (label) {
                                                                                            case numDefine233:
                                                                                                r0 = twoEStr65;
                                                                                                r1 = twoEStr166;
                                                                                                heapClassInst.heap32[g0] = r0;
                                                                                                heapClassInst.heap32[g0 + 1] = r1;
                                                                                                heapClassInst.heap32[g0 + numDefine2] = numDefine248;
                                                                                                assertNew(i7);
                                                                                                break;
                                                                                            case numDefine236:
                                                                                                if (r8 > 0) {
                                                                                                    r1 = 0;
                                                                                                    repeat315:
                                                                                                    while (true) {
                                                                                                        r3 = sp + numDefineNeg576;
                                                                                                        r4 = r1 << numDefine2;
                                                                                                        r3 = (r3 + r4) | 0;
                                                                                                        r3 = r3 >> numDefine2;
                                                                                                        r3 = heapClassInst.heap32[r3];
                                                                                                        r4 = (r3 * numDefine3) | 0;
                                                                                                        r4 = r4 << numDefine2;
                                                                                                        r4 = (r6 + r4) | 0;
                                                                                                        r4 = r4 >> numDefine2;
                                                                                                        f0 = heapClassInst.heapFloat[r4];
                                                                                                        f1 = heapClassInst.heapFloat[r0];
                                                                                                        f0 = f0 + f1;
                                                                                                        heapClassInst.heapFloat[fp + numDefineNeg148] = f0;
                                                                                                        r7 = sp + numDefineNeg592;
                                                                                                        f1 = heapClassInst.heapFloat[r4 + 1];
                                                                                                        f2 = heapClassInst.heapFloat[r0 + 1];
                                                                                                        f1 = f1 + f2;
                                                                                                        r8 = r7 >> numDefine2;
                                                                                                        heapClassInst.heapFloat[r8 + 1] = f1;
                                                                                                        f2 = heapClassInst.heapFloat[r4 + numDefine2];
                                                                                                        f3 = heapClassInst.heapFloat[r0 + numDefine2];
                                                                                                        f2 = f2 + f3;
                                                                                                        r4 = sp + numDefineNeg496;
                                                                                                        r3 = r3 << numDefine2;
                                                                                                        r3 = (r4 + r3) | 0;
                                                                                                        r4 = r5 >> numDefine2;
                                                                                                        heapClassInst.heapFloat[r8 + numDefine2] = f2;
                                                                                                        r4 = heapClassInst.heap32[r4];
                                                                                                        r3 = r3 >> numDefine2;
                                                                                                        r8 = sp + numDefineNeg704;
                                                                                                        f3 = heapClassInst.heapFloat[r3];
                                                                                                        r3 = r4 >> numDefine2;
                                                                                                        r4 = r8 >> numDefine2;
                                                                                                        r3 = heapClassInst.heap32[r3 + numDefine4];
                                                                                                        f4 = -f3;
                                                                                                        f5 = heapClassInst.heapFloat[r4 + numDefine2];
                                                                                                        if (r12 > numDefine3) {
                                                                                                            f6 = heapClassInst.heapFloat[fp + numDefineNeg176];
                                                                                                            f7 = heapClassInst.heapFloat[r4 + 1];
                                                                                                            f8 = f6 * f3;
                                                                                                            r4 = sp + numDefineNeg160;
                                                                                                            f9 = f7 * f3;
                                                                                                            f0 = f0 - f8;
                                                                                                            r7 = r4 >> numDefine2;
                                                                                                            f3 = f5 * f3;
                                                                                                            f1 = f1 - f9;
                                                                                                            heapClassInst.heapFloat[fp + numDefineNeg40] = f0;
                                                                                                            f0 = f2 - f3;
                                                                                                            heapClassInst.heapFloat[r7 + 1] = f1;
                                                                                                            heapClassInst.heapFloat[r7 + numDefine2] = f0;
                                                                                                            r8 = sp + numDefineNeg144;
                                                                                                            f0 = -f6;
                                                                                                            heapClassInst.heap32[r7 + numDefine3] = 0;
                                                                                                            r7 = r8 >> numDefine2;
                                                                                                            f1 = -f7;
                                                                                                            heapClassInst.heapFloat[fp + numDefineNeg36] = f0;
                                                                                                            f0 = -f5;
                                                                                                            heapClassInst.heapFloat[r7 + 1] = f1;
                                                                                                            heapClassInst.heapFloat[r7 + numDefine2] = f0;
                                                                                                            heapClassInst.heap32[r7 + numDefine3] = 0;
                                                                                                            heapClassInst.heap32[g0] = r5;
                                                                                                            heapClassInst.heap32[g0 + 1] = r8;
                                                                                                            heapClassInst.heap32[g0 + numDefine2] = r4;
                                                                                                            heapClassInst.heapFloat[g0 + numDefine3] = f4;
                                                                                                            functionTable.get(r3 >> numDefine2).accept(i7);
                                                                                                        } else {
                                                                                                            f0 = heapClassInst.heapFloat[r4 + 1];
                                                                                                            f1 = heapClassInst.heapFloat[fp + numDefineNeg176];
                                                                                                            r4 = sp + numDefineNeg176;
                                                                                                            f1 = -f1;
                                                                                                            r8 = r4 >> numDefine2;
                                                                                                            f0 = -f0;
                                                                                                            heapClassInst.heapFloat[fp + numDefineNeg44] = f1;
                                                                                                            f1 = -f5;
                                                                                                            heapClassInst.heapFloat[r8 + 1] = f0;
                                                                                                            heapClassInst.heapFloat[r8 + numDefine2] = f1;
                                                                                                            heapClassInst.heap32[r8 + numDefine3] = 0;
                                                                                                            heapClassInst.heap32[g0] = r5;
                                                                                                            heapClassInst.heap32[g0 + 1] = r4;
                                                                                                            heapClassInst.heap32[g0 + numDefine2] = r7;
                                                                                                            heapClassInst.heapFloat[g0 + numDefine3] = f4;
                                                                                                            functionTable.get(r3 >> numDefine2).accept(i7);
                                                                                                        }
                                                                                                        r1 = (r1 + 1) | 0;
                                                                                                        if (r1 >= r2) {
                                                                                                            break repeat41;
                                                                                                        } else {
                                                                                                            continue repeat315;
                                                                                                        }
                                                                                                    }
                                                                                                } else {
                                                                                                    break repeat41;
                                                                                                }
                                                                                            default:
                                                                                                break;
                                                                                        }
                                                                                    } else {
                                                                                        if (r12 < numDefine4) {
                                                                                            r1 = (r6 + numDefine8) | 0;
                                                                                            r2 = sp + numDefineNeg496;
                                                                                            repeat324:
                                                                                            while (true) {
                                                                                                r4 = r1 >> numDefine2;
                                                                                                f12 = heapClassInst.heapFloat[r4 + numDefineNeg2];
                                                                                                f20 = heapClassInst.heapFloat[r0];
                                                                                                f12 = f12 + f20;
                                                                                                heapClassInst.heapFloat[fp + numDefineNeg132] = f12;
                                                                                                r6 = sp + numDefineNeg528;
                                                                                                f12 = heapClassInst.heapFloat[r4 + -1];
                                                                                                f20 = heapClassInst.heapFloat[r0 + 1];
                                                                                                r7 = r6 >> numDefine2;
                                                                                                f12 = f12 + f20;
                                                                                                heapClassInst.heapFloat[r7 + 1] = f12;
                                                                                                f12 = heapClassInst.heapFloat[r4];
                                                                                                f20 = heapClassInst.heapFloat[r0 + numDefine2];
                                                                                                f12 = f12 + f20;
                                                                                                heapClassInst.heapFloat[r7 + numDefine2] = f12;
                                                                                                r4 = r5 >> numDefine2;
                                                                                                r4 = heapClassInst.heap32[r4];
                                                                                                r7 = sp + numDefineNeg704;
                                                                                                r7 = r7 >> numDefine2;
                                                                                                r4 = r4 >> numDefine2;
                                                                                                r8 = r2 >> numDefine2;
                                                                                                f12 = heapClassInst.heapFloat[r8];
                                                                                                f20 = heapClassInst.heapFloat[r7 + numDefine2];
                                                                                                f27 = heapClassInst.heapFloat[r7 + 1];
                                                                                                f0 = heapClassInst.heapFloat[fp + numDefineNeg176];
                                                                                                r4 = heapClassInst.heap32[r4 + numDefine4];
                                                                                                r7 = sp + numDefineNeg208;
                                                                                                f0 = -f0;
                                                                                                r8 = r7 >> numDefine2;
                                                                                                f27 = -f27;
                                                                                                heapClassInst.heapFloat[fp + numDefineNeg52] = f0;
                                                                                                f20 = -f20;
                                                                                                heapClassInst.heapFloat[r8 + 1] = f27;
                                                                                                heapClassInst.heapFloat[r8 + numDefine2] = f20;
                                                                                                heapClassInst.heap32[r8 + numDefine3] = 0;
                                                                                                f12 = -f12;
                                                                                                heapClassInst.heap32[g0] = r5;
                                                                                                heapClassInst.heap32[g0 + 1] = r7;
                                                                                                heapClassInst.heap32[g0 + numDefine2] = r6;
                                                                                                heapClassInst.heapFloat[g0 + numDefine3] = f12;
                                                                                                r3 = (r3 + -1) | 0;
                                                                                                r2 = (r2 + numDefine4) | 0;
                                                                                                r1 = (r1 + numDefine12) | 0;
                                                                                                functionTable.get(r4 >> numDefine2).accept(i7);
                                                                                                if (r3 == 0) {
                                                                                                    break repeat41;
                                                                                                } else {
                                                                                                    continue repeat324;
                                                                                                }
                                                                                            }
                                                                                        } else {
                                                                                            r1 = (r6 + numDefine8) | 0;
                                                                                            repeat327:
                                                                                            while (true) {
                                                                                                r2 = r7 >> numDefine2;
                                                                                                r4 = r1 >> numDefine2;
                                                                                                f12 = heapClassInst.heapFloat[r2];
                                                                                                f20 = heapClassInst.heapFloat[fp + numDefineNeg176];
                                                                                                f27 = heapClassInst.heapFloat[r4 + numDefineNeg2];
                                                                                                f0 = heapClassInst.heapFloat[r0];
                                                                                                f27 = f27 + f0;
                                                                                                f0 = f20 * f12;
                                                                                                r2 = sp + numDefineNeg704;
                                                                                                f27 = f27 - f0;
                                                                                                heapClassInst.heapFloat[fp + numDefineNeg136] = f27;
                                                                                                r2 = r2 >> numDefine2;
                                                                                                f27 = heapClassInst.heapFloat[r2 + 1];
                                                                                                f0 = heapClassInst.heapFloat[r4 + -1];
                                                                                                f1 = heapClassInst.heapFloat[r0 + 1];
                                                                                                r6 = sp + numDefineNeg544;
                                                                                                f0 = f0 + f1;
                                                                                                f1 = f27 * f12;
                                                                                                r8 = r6 >> numDefine2;
                                                                                                f0 = f0 - f1;
                                                                                                heapClassInst.heapFloat[r8 + 1] = f0;
                                                                                                f0 = heapClassInst.heapFloat[r2 + numDefine2];
                                                                                                f1 = heapClassInst.heapFloat[r4];
                                                                                                f2 = heapClassInst.heapFloat[r0 + numDefine2];
                                                                                                f1 = f1 + f2;
                                                                                                f2 = f0 * f12;
                                                                                                f1 = f1 - f2;
                                                                                                r2 = r5 >> numDefine2;
                                                                                                heapClassInst.heapFloat[r8 + numDefine2] = f1;
                                                                                                r2 = heapClassInst.heap32[r2];
                                                                                                r2 = r2 >> numDefine2;
                                                                                                r2 = heapClassInst.heap32[r2 + numDefine4];
                                                                                                r4 = sp + numDefineNeg192;
                                                                                                f20 = -f20;
                                                                                                r8 = r4 >> numDefine2;
                                                                                                f27 = -f27;
                                                                                                heapClassInst.heapFloat[fp + numDefineNeg48] = f20;
                                                                                                f20 = -f0;
                                                                                                heapClassInst.heapFloat[r8 + 1] = f27;
                                                                                                heapClassInst.heapFloat[r8 + numDefine2] = f20;
                                                                                                heapClassInst.heap32[r8 + numDefine3] = 0;
                                                                                                f12 = -f12;
                                                                                                heapClassInst.heap32[g0] = r5;
                                                                                                heapClassInst.heap32[g0 + 1] = r4;
                                                                                                heapClassInst.heap32[g0 + numDefine2] = r6;
                                                                                                heapClassInst.heapFloat[g0 + numDefine3] = f12;
                                                                                                r3 = (r3 + -1) | 0;
                                                                                                r7 = (r7 + numDefine4) | 0;
                                                                                                r1 = (r1 + numDefine12) | 0;
                                                                                                functionTable.get(r2 >> numDefine2).accept(i7);
                                                                                                if (r3 == 0) {
                                                                                                    break repeat41;
                                                                                                } else {
                                                                                                    continue repeat327;
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        } else {
                                                                            r0 = sp + numDefineNeg688;
                                                                            r2 = r0 >> numDefine2;
                                                                            f20 = heapClassInst.heapFloat[fp + numDefineNeg172];
                                                                            f27 = heapClassInst.heapFloat[r2 + numDefine4];
                                                                            f2 = heapClassInst.heapFloat[r2 + numDefine5];
                                                                            f3 = heapClassInst.heapFloat[r2 + 1];
                                                                            f4 = f0 * f20;
                                                                            f5 = f1 * f27;
                                                                            f6 = heapClassInst.heapFloat[r2 + numDefine8];
                                                                            f7 = heapClassInst.heapFloat[r2 + numDefine9];
                                                                            f8 = heapClassInst.heapFloat[r2 + numDefine6];
                                                                            f9 = heapClassInst.heapFloat[r2 + numDefine2];
                                                                            f4 = f4 + f5;
                                                                            f5 = f19 * f6;
                                                                            f10 = f0 * f3;
                                                                            f11 = f1 * f2;
                                                                            f12 = heapClassInst.heapFloat[r2 + numDefine10];
                                                                            f4 = f4 + f5;
                                                                            f5 = f10 + f11;
                                                                            f10 = f19 * f7;
                                                                            f11 = f0 * f9;
                                                                            f13 = f1 * f8;
                                                                            f14 = 0;
                                                                            f15 = -1;
                                                                            f16 = 1;
                                                                            f5 = f5 + f10;
                                                                            f4 = f4 > f14 ? f15 : f16;
                                                                            f10 = f11 + f13;
                                                                            f11 = f19 * f12;
                                                                            f13 = heapClassInst.heapFloat[fp + numDefineNeg181];
                                                                            f4 = f13 * f4;
                                                                            f10 = f10 + f11;
                                                                            f5 = f5 > f14 ? f15 : f16;
                                                                            f11 = heapClassInst.heapFloat[fp + numDefineNeg182];
                                                                            f5 = f11 * f5;
                                                                            r2 = sp + numDefineNeg640;
                                                                            f20 = f4 * f20;
                                                                            f11 = heapClassInst.heapFloat[r1 + numDefine28];
                                                                            f10 = f10 > f14 ? f15 : f16;
                                                                            r3 = r2 >> numDefine2;
                                                                            f13 = heapClassInst.heapFloat[fp + numDefineNeg180];
                                                                            f10 = f13 * f10;
                                                                            f27 = f4 * f27;
                                                                            f13 = heapClassInst.heapFloat[r1 + numDefine29];
                                                                            f20 = f11 + f20;
                                                                            f3 = f5 * f3;
                                                                            r4 = (r12 + numDefineNeg7) | 0;
                                                                            f11 = heapClassInst.heapFloat[r3 + numDefine4];
                                                                            f17 = heapClassInst.heapFloat[fp + numDefineNeg160];
                                                                            f18 = heapClassInst.heapFloat[r3 + numDefine8];
                                                                            f21 = heapClassInst.heapFloat[r3 + numDefine5];
                                                                            f22 = heapClassInst.heapFloat[r3 + 1];
                                                                            f23 = heapClassInst.heapFloat[r3 + numDefine9];
                                                                            f24 = heapClassInst.heapFloat[r3 + numDefine6];
                                                                            f25 = heapClassInst.heapFloat[r3 + numDefine2];
                                                                            f26 = heapClassInst.heapFloat[r3 + numDefine10];
                                                                            f4 = f4 * f6;
                                                                            f6 = heapClassInst.heapFloat[r1 + numDefine30];
                                                                            f27 = f13 + f27;
                                                                            f2 = f5 * f2;
                                                                            f20 = f20 + f3;
                                                                            f3 = f10 * f9;
                                                                            f9 = heapClassInst.heapFloat[r1 + numDefine12];
                                                                            heapClassInst.heapFloat[fp + numDefineNeg182] = f9;
                                                                            f9 = heapClassInst.heapFloat[r1 + numDefine13];
                                                                            heapClassInst.heapFloat[fp + numDefineNeg181] = f9;
                                                                            f9 = heapClassInst.heapFloat[r1 + numDefine14];
                                                                            heapClassInst.heapFloat[fp + numDefineNeg180] = f9;
                                                                            r3 = (r4 / numDefine3) | 0;
                                                                            r4 = r4 % numDefine3 | 0;
                                                                            r10 = sp + numDefineNeg512;
                                                                            f20 = f20 + f3;
                                                                            f3 = f6 + f4;
                                                                            f4 = f5 * f7;
                                                                            f27 = f27 + f2;
                                                                            f2 = f10 * f8;
                                                                            r3 = r3 << numDefine2;
                                                                            r4 = r4 << numDefine2;
                                                                            f27 = f27 + f2;
                                                                            r12 = r10 >> numDefine2;
                                                                            heapClassInst.heapFloat[fp + numDefineNeg128] = f20;
                                                                            f2 = f3 + f4;
                                                                            f3 = f10 * f12;
                                                                            r2 = (r2 + r3) | 0;
                                                                            r0 = (r0 + r4) | 0;
                                                                            f2 = f2 + f3;
                                                                            heapClassInst.heapFloat[r12 + 1] = f27;
                                                                            r2 = r2 >> numDefine2;
                                                                            heapClassInst.heapFloat[r12 + numDefine2] = f2;
                                                                            r0 = r0 >> numDefine2;
                                                                            f3 = heapClassInst.heapFloat[r2];
                                                                            f4 = heapClassInst.heapFloat[r0];
                                                                            f5 = heapClassInst.heapFloat[r2 + numDefine4];
                                                                            f6 = heapClassInst.heapFloat[r0 + numDefine4];
                                                                            f7 = heapClassInst.heapFloat[r2 + numDefine8];
                                                                            f8 = heapClassInst.heapFloat[r0 + numDefine8];
                                                                            f9 = f3 * f4;
                                                                            f10 = f5 * f6;
                                                                            f9 = f9 + f10;
                                                                            f10 = f7 * f8;
                                                                            f9 = f9 + f10;
                                                                            f10 = f9 * f9;
                                                                            f10 = f16 - f10;
                                                                            f12 = (float) numDefineFloat9165;
                                                                            if (f10 > f12) {
                                                                                f12 = f0 * f17;
                                                                                f13 = f1 * f11;
                                                                                f12 = f12 + f13;
                                                                                f13 = f19 * f18;
                                                                                f28 = f0 * f22;
                                                                                f29 = f1 * f21;
                                                                                f12 = f12 + f13;
                                                                                f13 = f28 + f29;
                                                                                f28 = f19 * f23;
                                                                                f29 = f0 * f25;
                                                                                f30 = f1 * f24;
                                                                                f13 = f13 + f28;
                                                                                f12 = f12 > f14 ? f16 : f15;
                                                                                f28 = f29 + f30;
                                                                                f29 = f19 * f26;
                                                                                f30 = heapClassInst.heapFloat[fp + numDefineNeg179];
                                                                                f12 = f30 * f12;
                                                                                f28 = f28 + f29;
                                                                                f13 = f13 > f14 ? f16 : f15;
                                                                                f29 = heapClassInst.heapFloat[fp + numDefineNeg178];
                                                                                f13 = f29 * f13;
                                                                                f17 = f12 * f17;
                                                                                f11 = f12 * f11;
                                                                                f12 = f12 * f18;
                                                                                f14 = f28 > f14 ? f16 : f15;
                                                                                f15 = heapClassInst.heapFloat[fp + numDefineNeg177];
                                                                                f14 = f15 * f14;
                                                                                f15 = heapClassInst.heapFloat[fp + numDefineNeg182];
                                                                                f15 = f15 + f17;
                                                                                f17 = f13 * f22;
                                                                                f18 = heapClassInst.heapFloat[fp + numDefineNeg181];
                                                                                f11 = f18 + f11;
                                                                                f18 = f13 * f21;
                                                                                f21 = heapClassInst.heapFloat[fp + numDefineNeg180];
                                                                                f12 = f21 + f12;
                                                                                f13 = f13 * f23;
                                                                                f15 = f15 + f17;
                                                                                f17 = f14 * f25;
                                                                                f11 = f11 + f18;
                                                                                f18 = f14 * f24;
                                                                                f12 = f12 + f13;
                                                                                f14 = f14 * f26;
                                                                                f13 = f15 + f17;
                                                                                f11 = f11 + f18;
                                                                                f14 = f12 + f14;
                                                                                f12 = f20 - f13;
                                                                                f11 = f27 - f11;
                                                                                f14 = f2 - f14;
                                                                                f3 = f3 * f12;
                                                                                f5 = f5 * f11;
                                                                                f3 = f3 + f5;
                                                                                f5 = f7 * f14;
                                                                                f7 = f4 * f12;
                                                                                f11 = f6 * f11;
                                                                                f3 = f3 + f5;
                                                                                f5 = f7 + f11;
                                                                                f14 = f8 * f14;
                                                                                f3 = f9 * f3;
                                                                                f14 = f5 + f14;
                                                                                f14 = f3 - f14;
                                                                                f3 = f16 / f10;
                                                                                f14 = f14 * f3;
                                                                            }
                                                                            f3 = f4 * f14;
                                                                            f20 = f20 + f3;
                                                                            f3 = f6 * f14;
                                                                            f4 = f8 * f14;
                                                                            f27 = f27 + f3;
                                                                            heapClassInst.heapFloat[fp + numDefineNeg128] = f20;
                                                                            f20 = f2 + f4;
                                                                            heapClassInst.heapFloat[r12 + 1] = f27;
                                                                            r0 = r5 >> numDefine2;
                                                                            heapClassInst.heapFloat[r12 + numDefine2] = f20;
                                                                            r0 = heapClassInst.heap32[r0];
                                                                            r0 = r0 >> numDefine2;
                                                                            r0 = heapClassInst.heap32[r0 + numDefine4];
                                                                            r2 = sp + numDefineNeg224;
                                                                            f0 = -f0;
                                                                            r3 = r2 >> numDefine2;
                                                                            f1 = -f1;
                                                                            heapClassInst.heapFloat[fp + numDefineNeg56] = f0;
                                                                            f0 = -f19;
                                                                            heapClassInst.heapFloat[r3 + 1] = f1;
                                                                            heapClassInst.heapFloat[r3 + numDefine2] = f0;
                                                                            heapClassInst.heap32[r3 + numDefine3] = 0;
                                                                            heapClassInst.heap32[g0] = r5;
                                                                            heapClassInst.heap32[g0 + 1] = r2;
                                                                            heapClassInst.heap32[g0 + numDefine2] = r10;
                                                                            f0 = heapClassInst.heapFloat[fp + numDefineNeg183];
                                                                            heapClassInst.heapFloat[g0 + numDefine3] = f0;
                                                                            functionTable.get(r0 >> numDefine2).accept(i7);
                                                                            
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        } while (false);
        
    }

    public static void zn21btCollisionDispatcher13findAlgorithmEP17btCollisionObjectS1P20btPersistentManifold(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        int r6 = 0;
        int label = 0;
        i7 = sp + numDefineNeg24;
        int g0 = i7 >> numDefine2;
        r0 = sp + numDefineNeg8;
        r1 = heapClassInst.heap32[fp];
        r2 = heapClassInst.heap32[fp + 1];
        r3 = r0 >> numDefine2;
        r4 = heapClassInst.heap32[fp + numDefine3];
        heapClassInst.heap32[fp + numDefineNeg2] = r1;
        r5 = heapClassInst.heap32[fp + numDefine2];
        r6 = r2 >> numDefine2;
        heapClassInst.heap32[r3 + 1] = r4;
        r3 = heapClassInst.heap32[r6 + numDefine48];
        r4 = r5 >> numDefine2;
        r3 = r3 >> numDefine2;
        r4 = heapClassInst.heap32[r4 + numDefine48];
        r3 = heapClassInst.heap32[r3 + 1];
        r4 = r4 >> numDefine2;
        r4 = heapClassInst.heap32[r4 + 1];
        r3 = (r3 * numDefine144) | 0;
        r1 = (r1 + r3) | 0;
        r3 = r4 << numDefine2;
        r1 = (r1 + r3) | 0;
        r1 = r1 >> numDefine2;
        r1 = heapClassInst.heap32[r1 + numDefine50];
        r3 = r1 >> numDefine2;
        r3 = heapClassInst.heap32[r3];
        r3 = r3 >> numDefine2;
        r3 = heapClassInst.heap32[r3 + numDefine2];
        heapClassInst.heap32[g0] = r1;
        heapClassInst.heap32[g0 + 1] = r0;
        heapClassInst.heap32[g0 + numDefine2] = r2;
        heapClassInst.heap32[g0 + numDefine3] = r5;
        functionTable.get(r3 >> numDefine2).accept(i7);
        
    }

    public static void zn21btCollisionDispatcher13needsResponseEP17btCollisionObjectS1(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int label = 0;
        i7 = sp + 0;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp + 1];
        r0 = r0 >> numDefine2;
        r0 = heapClassInst.heap32[r0 + numDefine51];
        r1 = r0 & numDefine4;
        if (!(r1 != 0)) {
            r1 = heapClassInst.heap32[fp + numDefine2];
            r1 = r1 >> numDefine2;
            r1 = heapClassInst.heap32[r1 + numDefine51];
            r2 = r1 & numDefine4;
            if (!(r2 != 0)) {
                r0 = r0 & numDefine3;
                if (r0 == 0) {
                    r0 = 1;
                    commonVariable.rg0 = r0;
                    
                } else {
                    r0 = r1 & numDefine3;
                    r1 = 0;
                    r0 = r0 == r1 ? 1 : 0;
                    r0 = r0 & 1;
                    commonVariable.rg0 = r0;
                    
                }
            }
        }
        r0 = 0;
        commonVariable.rg0 = r0;
        
    }

    public static void zn23btCollisionPairCallbackD1Ev(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int label = 0;
        i7 = sp + 0;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = ztv23btCollisionPairCallback;
        r0 = r0 >> numDefine2;
        r1 = (r1 + numDefine8) | 0;
        heapClassInst.heap32[r0] = r1;
        
    }

    public static void zn23btCollisionPairCallbackD0Ev(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int label = 0;
        i7 = sp + numDefineNeg8;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = ztv23btCollisionPairCallback;
        r2 = r0 >> numDefine2;
        r1 = (r1 + numDefine8) | 0;
        heapClassInst.heap32[r2] = r1;
        heapClassInst.heap32[g0] = r0;
        zdlPv(i7);
        
    }

    public static void zn23btCollisionPairCallback14processOverlapER16btBroadphasePair(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int label = 0;
        i7 = sp + numDefineNeg16;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r0 = r0 >> numDefine2;
        r1 = heapClassInst.heap32[r0 + numDefine2];
        r2 = r1 >> numDefine2;
        r2 = heapClassInst.heap32[r2 + numDefine47];
        r0 = heapClassInst.heap32[r0 + 1];
        r3 = heapClassInst.heap32[fp + 1];
        heapClassInst.heap32[g0] = r3;
        heapClassInst.heap32[g0 + 1] = r1;
        heapClassInst.heap32[g0 + numDefine2] = r0;
        functionTable.get(r2 >> numDefine2).accept(i7);
        r0 = 0;
        commonVariable.rg0 = r0;
        
    }

    public static void zn21btCollisionDispatcher25dispatchAllCollisionPairsEP22btOverlappingPairCacheRK16btDispatcherInfoP12btDispatcher(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int label = 0;
        i7 = sp + numDefineNeg32;
        int g0 = i7 >> numDefine2;
        r0 = ztv23btCollisionPairCallback;
        r1 = sp + numDefineNeg16;
        r0 = (r0 + numDefine8) | 0;
        r2 = r1 >> numDefine2;
        r3 = heapClassInst.heap32[fp + numDefine2];
        heapClassInst.heap32[fp + numDefineNeg4] = r0;
        r0 = heapClassInst.heap32[fp + 1];
        r4 = heapClassInst.heap32[fp];
        heapClassInst.heap32[r2 + 1] = r3;
        r3 = r0 >> numDefine2;
        heapClassInst.heap32[r2 + numDefine2] = r4;
        r2 = heapClassInst.heap32[r3];
        r2 = r2 >> numDefine2;
        r2 = heapClassInst.heap32[r2 + numDefine12];
        r3 = heapClassInst.heap32[fp + numDefine3];
        heapClassInst.heap32[g0] = r0;
        heapClassInst.heap32[g0 + 1] = r1;
        heapClassInst.heap32[g0 + numDefine2] = r3;
        functionTable.get(r2 >> numDefine2).accept(i7);
        
    }

    public static void znk21btCollisionDispatcher15getNumManifoldsEv(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int label = 0;
        i7 = sp + 0;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r0 = r0 >> numDefine2;
        r0 = heapClassInst.heap32[r0 + numDefine3];
        commonVariable.rg0 = r0;
        
    }

    public static void zn21btCollisionDispatcher26getInternalManifoldPointerEv(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int label = 0;
        i7 = sp + 0;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r0 = r0 >> numDefine2;
        r0 = heapClassInst.heap32[r0 + numDefine5];
        commonVariable.rg0 = r0;
        
    }

    public static void zn21btCollisionDispatcher26getManifoldByIndexInternalEi(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int label = 0;
        i7 = sp + 0;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r0 = r0 >> numDefine2;
        r1 = heapClassInst.heap32[fp + 1];
        r0 = heapClassInst.heap32[r0 + numDefine5];
        r1 = r1 << numDefine2;
        r0 = (r0 + r1) | 0;
        r0 = r0 >> numDefine2;
        r0 = heapClassInst.heap32[r0];
        commonVariable.rg0 = r0;
        
    }

    public static void zn21btCollisionDispatcher22freeCollisionAlgorithmEPv(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int label = 0;
        i7 = sp + numDefineNeg8;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp + 1];
        if (!(r0 == 0)) {
            r1 = heapClassInst.heap32[fp];
            r1 = r1 >> numDefine2;
            r1 = heapClassInst.heap32[r1 + numDefine48];
            r1 = r1 >> numDefine2;
            r2 = heapClassInst.heap32[r1 + numDefine4];
            if (!(uint(r2) > uint(r0))) {
                r3 = heapClassInst.heap32[r1];
                r4 = heapClassInst.heap32[r1 + 1];
                r3 = (r3 * r4) | 0;
                r2 = (r2 + r3) | 0;
                if (!(uint(r2) <= uint(r0))) {
                    r2 = r0 >> numDefine2;
                    r3 = heapClassInst.heap32[r1 + numDefine3];
                    heapClassInst.heap32[r2] = r3;
                    heapClassInst.heap32[r1 + numDefine3] = r0;
                    r0 = heapClassInst.heap32[r1 + numDefine2];
                    r0 = (r0 + 1) | 0;
                    heapClassInst.heap32[r1 + numDefine2] = r0;
                    
                }
            }
            r1 = gNumAlignedFree;
            r1 = r1 >> numDefine2;
            r2 = heapClassInst.heap32[r1];
            r2 = (r2 + 1) | 0;
            r0 = r0 >> numDefine2;
            heapClassInst.heap32[r1] = r2;
            r0 = heapClassInst.heap32[r0 + -1];
            heapClassInst.heap32[g0] = r0;
            free(i7);
        }
        
    }

    public static void zn21btCollisionDispatcher15releaseManifoldEP20btPersistentManifold(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        int r6 = 0;
        int r7 = 0;
        int r8 = 0;
        int label = 0;
        i7 = sp + numDefineNeg16;
        int g0 = i7 >> numDefine2;
        r0 = gNumManifold;
        r0 = r0 >> numDefine2;
        r1 = heapClassInst.heap32[r0];
        r2 = heapClassInst.heap32[fp];
        r1 = (r1 + -1) | 0;
        r3 = r2 >> numDefine2;
        heapClassInst.heap32[r0] = r1;
        r0 = heapClassInst.heap32[r3];
        r0 = r0 >> numDefine2;
        r0 = heapClassInst.heap32[r0 + numDefine5];
        r1 = heapClassInst.heap32[fp + 1];
        heapClassInst.heap32[g0] = r2;
        heapClassInst.heap32[g0 + 1] = r1;
        functionTable.get(r0 >> numDefine2).accept(i7);
        r0 = r1 >> numDefine2;
        r2 = heapClassInst.heap32[r3 + numDefine3];
        r4 = heapClassInst.heap32[r0 + numDefine284];
        if (r2 > r4) {
            r2 = (r2 + -1) | 0;
            r5 = r4 << numDefine2;
            r6 = heapClassInst.heap32[r3 + numDefine5];
            r2 = r2 << numDefine2;
            r7 = (r6 + r5) | 0;
            r6 = (r6 + r2) | 0;
            r7 = r7 >> numDefine2;
            r6 = r6 >> numDefine2;
            r8 = heapClassInst.heap32[r7];
            r6 = heapClassInst.heap32[r6];
            heapClassInst.heap32[r7] = r6;
            r6 = heapClassInst.heap32[r3 + numDefine5];
            r2 = (r6 + r2) | 0;
            r2 = r2 >> numDefine2;
            heapClassInst.heap32[r2] = r8;
            r2 = heapClassInst.heap32[r3 + numDefine5];
            r2 = (r2 + r5) | 0;
            r2 = r2 >> numDefine2;
            r2 = heapClassInst.heap32[r2];
            r2 = r2 >> numDefine2;
            heapClassInst.heap32[r2 + numDefine284] = r4;
            r2 = heapClassInst.heap32[r3 + numDefine3];
            r2 = (r2 + -1) | 0;
            heapClassInst.heap32[r3 + numDefine3] = r2;
            if (!(r1 == 0)) {
                r2 = heapClassInst.heap32[r3 + numDefine49];
                r2 = r2 >> numDefine2;
                r3 = heapClassInst.heap32[r2 + numDefine4];
                if (!(uint(r3) > uint(r1))) {
                    r4 = heapClassInst.heap32[r2];
                    r5 = heapClassInst.heap32[r2 + 1];
                    r4 = (r4 * r5) | 0;
                    r3 = (r3 + r4) | 0;
                    if (!(uint(r3) <= uint(r1))) {
                        r3 = heapClassInst.heap32[r2 + numDefine3];
                        heapClassInst.heap32[r0] = r3;
                        heapClassInst.heap32[r2 + numDefine3] = r1;
                        r0 = heapClassInst.heap32[r2 + numDefine2];
                        r0 = (r0 + 1) | 0;
                        heapClassInst.heap32[r2 + numDefine2] = r0;
                        
                    }
                }
                r1 = gNumAlignedFree;
                r1 = r1 >> numDefine2;
                r2 = heapClassInst.heap32[r1];
                r2 = (r2 + 1) | 0;
                heapClassInst.heap32[r1] = r2;
                r0 = heapClassInst.heap32[r0 + -1];
                heapClassInst.heap32[g0] = r0;
                free(i7);
            }
            
        } else {
            r0 = twoEStr472;
            r1 = twoEStr573;
            heapClassInst.heap32[g0] = r0;
            heapClassInst.heap32[g0 + 1] = r1;
            heapClassInst.heap32[g0 + numDefine2] = numDefine120;
            assertNew(i7);
        }
        
    }

    public static void zn21btCollisionDispatcherD1Ev(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int label = 0;
        i7 = sp + numDefineNeg8;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = ztv21btCollisionDispatcher;
        r2 = ztv16btManifoldResult;
        r3 = r0 >> numDefine2;
        r1 = (r1 + numDefine8) | 0;
        r2 = (r2 + numDefine8) | 0;
        heapClassInst.heap32[r3] = r1;
        heapClassInst.heap32[r3 + numDefine7] = r2;
        r1 = heapClassInst.heap32[r3 + numDefine5];
        if (!(r1 == 0)) {
            r2 = heapClassInst.heapU8[r0 + numDefine24];
            if (!(r2 == 0)) {
                r2 = gNumAlignedFree;
                r2 = r2 >> numDefine2;
                r4 = heapClassInst.heap32[r2];
                r4 = (r4 + 1) | 0;
                r1 = r1 >> numDefine2;
                heapClassInst.heap32[r2] = r4;
                r1 = heapClassInst.heap32[r1 + -1];
                heapClassInst.heap32[g0] = r1;
                free(i7);
            }
            heapClassInst.heap32[r3 + numDefine5] = 0;
        }
        r1 = 1;
        heapClassInst.heap8[r0 + numDefine24] = (byte) r1;
        heapClassInst.heap32[r3 + numDefine5] = 0;
        r0 = ztv12btDispatcher;
        heapClassInst.heap32[r3 + numDefine3] = 0;
        r0 = (r0 + numDefine8) | 0;
        heapClassInst.heap32[r3 + numDefine4] = 0;
        heapClassInst.heap32[r3] = r0;
        
    }

    public static void zn21btCollisionDispatcherD0Ev(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int label = 0;
        i7 = sp + numDefineNeg8;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = ztv21btCollisionDispatcher;
        r2 = ztv16btManifoldResult;
        r3 = r0 >> numDefine2;
        r1 = (r1 + numDefine8) | 0;
        r2 = (r2 + numDefine8) | 0;
        heapClassInst.heap32[r3] = r1;
        heapClassInst.heap32[r3 + numDefine7] = r2;
        r1 = heapClassInst.heap32[r3 + numDefine5];
        if (!(r1 == 0)) {
            r2 = heapClassInst.heapU8[r0 + numDefine24];
            if (!(r2 == 0)) {
                r2 = gNumAlignedFree;
                r2 = r2 >> numDefine2;
                r4 = heapClassInst.heap32[r2];
                r4 = (r4 + 1) | 0;
                r1 = r1 >> numDefine2;
                heapClassInst.heap32[r2] = r4;
                r1 = heapClassInst.heap32[r1 + -1];
                heapClassInst.heap32[g0] = r1;
                free(i7);
            }
            heapClassInst.heap32[r3 + numDefine5] = 0;
        }
        r1 = 1;
        heapClassInst.heap8[r0 + numDefine24] = (byte) r1;
        heapClassInst.heap32[r3 + numDefine5] = 0;
        r1 = ztv12btDispatcher;
        heapClassInst.heap32[r3 + numDefine3] = 0;
        r1 = (r1 + numDefine8) | 0;
        heapClassInst.heap32[r3 + numDefine4] = 0;
        heapClassInst.heap32[r3] = r1;
        heapClassInst.heap32[g0] = r0;
        zdlPv(i7);
        
    }

    public static void zn21btCollisionDispatcher14getNewManifoldEPvS0(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        int r6 = 0;
        int r7 = 0;
        int r8 = 0;
        int r9 = 0;
        int r10 = 0;
        int r11 = 0;
        float f0 = 0.0F;
        float f1 = 0.0F;
        float f2 = 0.0F;
        int label = 0;
        i7 = sp + numDefineNeg24;
        int g0 = i7 >> numDefine2;
        r0 = gNumManifold;
        r0 = r0 >> numDefine2;
        r1 = heapClassInst.heap32[r0];
        r1 = (r1 + 1) | 0;
        r2 = heapClassInst.heap32[fp];
        r3 = heapClassInst.heap32[fp + 1];
        r4 = heapClassInst.heap32[fp + numDefine2];
        heapClassInst.heap32[r0] = r1;
        r0 = heapClassInst.heapU8[r2 + numDefine4];
        r0 = r0 & numDefine2;
        if (r0 != 0) {
            r0 = r4 >> numDefine2;
            r0 = heapClassInst.heap32[r0 + numDefine48];
            r1 = r0 >> numDefine2;
            r1 = heapClassInst.heap32[r1];
            r1 = r1 >> numDefine2;
            r1 = heapClassInst.heap32[r1 + numDefine5];
            heapClassInst.heap32[g0] = r0;
            heapClassInst.heap32[g0 + 1] = (int) numDefine70378;
            functionTable.get(r1 >> numDefine2).accept(i7);
            f0 = (float) commonVariable.fg0;
            r0 = r3 >> numDefine2;
            heapClassInst.heapFloat[fp + numDefineNeg2] = f0;
            r0 = heapClassInst.heap32[r0 + numDefine48];
            r1 = r0 >> numDefine2;
            r1 = heapClassInst.heap32[r1];
            r1 = r1 >> numDefine2;
            r1 = heapClassInst.heap32[r1 + numDefine5];
            heapClassInst.heap32[g0] = r0;
            heapClassInst.heap32[g0 + 1] = (int) numDefine70378;
            functionTable.get(r1 >> numDefine2).accept(i7);
            r0 = sp + numDefineNeg4;
            r1 = sp + numDefineNeg8;
            r0 = commonVariable.fg0 < f0 ? r0 : r1;
            heapClassInst.heapFloat[fp + -1] = (float) commonVariable.fg0;
        } else {
            r0 = gContactBreakingThreshold;
        }
        r1 = r2 >> numDefine2;
        r5 = heapClassInst.heap32[r1 + numDefine49];
        r6 = r3 >> numDefine2;
        r7 = r4 >> numDefine2;
        r5 = r5 >> numDefine2;
        r0 = r0 >> numDefine2;
        f0 = heapClassInst.heapFloat[r6 + numDefine46];
        f1 = heapClassInst.heapFloat[r7 + numDefine46];
        r6 = heapClassInst.heap32[r5 + numDefine2];
        f2 = heapClassInst.heapFloat[r0];
        f0 = f0 < f1 ? f0 : f1;
        repeat5:
        do {
            if (r6 == 0) {
                r0 = gNumAlignedAllocs;
                r0 = r0 >> numDefine2;
                r5 = heapClassInst.heap32[r0];
                r5 = (r5 + 1) | 0;
                heapClassInst.heap32[r0] = r5;
                heapClassInst.heap32[g0] = numDefine1159;
                mallocNew(i7);
                r0 = commonVariable.rg0;
                if (r0 != 0) {
                    r5 = 0;
                    r6 = (r0 + numDefine4) | 0;
                    r5 = (r5 - r6) | 0;
                    r5 = r5 & numDefine15;
                    r5 = (r0 + r5) | 0;
                    r6 = (r5 + numDefine4) | 0;
                    r5 = r5 >> numDefine2;
                    heapClassInst.heap32[r5] = r0;
                    r0 = r6;
                } else {
                    break repeat5;
                }
            } else {
                r0 = heapClassInst.heap32[r5];
                if (r0 > numDefine1139) {
                    if (r6 > 0) {
                        r0 = heapClassInst.heap32[r5 + numDefine3];
                        r7 = r0 >> numDefine2;
                        r7 = heapClassInst.heap32[r7];
                        r6 = (r6 + -1) | 0;
                        heapClassInst.heap32[r5 + numDefine3] = r7;
                        heapClassInst.heap32[r5 + numDefine2] = r6;
                    } else {
                        r1 = twoEStr371;
                        r2 = twoEStr169;
                        heapClassInst.heap32[g0] = r1;
                        heapClassInst.heap32[g0 + 1] = r2;
                        heapClassInst.heap32[g0 + numDefine2] = numDefine70;
                        assertNew(i7);
                    }
                } else {
                    r1 = twoEStr270;
                    r2 = twoEStr169;
                    heapClassInst.heap32[g0] = r1;
                    heapClassInst.heap32[g0 + 1] = r2;
                    heapClassInst.heap32[g0 + numDefine2] = numDefine69;
                    assertNew(i7);
                }
            }
        } while (false);
        r5 = r0 >> numDefine2;
        heapClassInst.heap32[r5] = 1;
        heapClassInst.heap32[r5 + numDefine28] = 0;
        r6 = 0;
        heapClassInst.heap32[r5 + numDefine29] = 0;
        heapClassInst.heap8[r0 + numDefine120] = (byte) r6;
        heapClassInst.heap32[r5 + numDefine31] = 0;
        heapClassInst.heap32[r5 + numDefine32] = 0;
        heapClassInst.heap32[r5 + numDefine33] = 0;
        heapClassInst.heap32[r5 + numDefine34] = 0;
        heapClassInst.heap32[r5 + numDefine35] = 0;
        heapClassInst.heap32[r5 + numDefine36] = 0;
        heapClassInst.heap32[r5 + numDefine37] = 0;
        heapClassInst.heap32[r5 + numDefine97] = 0;
        heapClassInst.heap32[r5 + numDefine98] = 0;
        heapClassInst.heap8[r0 + numDefine396] = (byte) r6;
        heapClassInst.heap32[r5 + numDefine100] = 0;
        heapClassInst.heap32[r5 + numDefine101] = 0;
        heapClassInst.heap32[r5 + numDefine102] = 0;
        heapClassInst.heap32[r5 + numDefine103] = 0;
        heapClassInst.heap32[r5 + numDefine104] = 0;
        heapClassInst.heap32[r5 + numDefine105] = 0;
        heapClassInst.heap32[r5 + numDefine106] = 0;
        heapClassInst.heap32[r5 + numDefine166] = 0;
        heapClassInst.heap32[r5 + numDefine167] = 0;
        heapClassInst.heap8[r0 + numDefine672] = (byte) r6;
        heapClassInst.heap32[r5 + numDefine169] = 0;
        heapClassInst.heap32[r5 + numDefine170] = 0;
        heapClassInst.heap32[r5 + numDefine171] = 0;
        heapClassInst.heap32[r5 + numDefine172] = 0;
        heapClassInst.heap32[r5 + numDefine173] = 0;
        heapClassInst.heap32[r5 + numDefine174] = 0;
        heapClassInst.heap32[r5 + numDefine175] = 0;
        heapClassInst.heap32[r5 + numDefine235] = 0;
        heapClassInst.heap32[r5 + numDefine236] = 0;
        heapClassInst.heap8[r0 + numDefine948] = (byte) r6;
        heapClassInst.heap32[r5 + numDefine238] = 0;
        heapClassInst.heap32[r5 + numDefine239] = 0;
        heapClassInst.heap32[r5 + numDefine240] = 0;
        heapClassInst.heap32[r5 + numDefine241] = 0;
        heapClassInst.heap32[r5 + numDefine242] = 0;
        heapClassInst.heap32[r5 + numDefine243] = 0;
        heapClassInst.heap32[r5 + numDefine244] = 0;
        heapClassInst.heap32[r5 + numDefine277] = r3;
        heapClassInst.heap32[r5 + numDefine278] = r4;
        heapClassInst.heap32[r5 + numDefine279] = 0;
        heapClassInst.heapFloat[r5 + numDefine280] = f2;
        heapClassInst.heapFloat[r5 + numDefine281] = f0;
        r3 = heapClassInst.heap32[r1 + numDefine3];
        heapClassInst.heap32[r5 + numDefine284] = r3;
        r3 = heapClassInst.heap32[r1 + numDefine4];
        r4 = heapClassInst.heap32[r1 + numDefine3];
        if (r3 == r4) {
            r5 = 1;
            r7 = r4 << 1;
            r7 = r4 == 0 ? r5 : r7;
            if (!(r3 >= r7)) {
                if (r7 != 0) {
                    r3 = gNumAlignedAllocs;
                    r3 = r3 >> numDefine2;
                    r8 = heapClassInst.heap32[r3];
                    r9 = r7 << numDefine2;
                    r8 = (r8 + 1) | 0;
                    r9 = r9 | numDefine3;
                    heapClassInst.heap32[r3] = r8;
                    r3 = (r9 + numDefine16) | 0;
                    heapClassInst.heap32[g0] = r3;
                    mallocNew(i7);
                    r3 = commonVariable.rg0;
                    if (r3 != 0) {
                        r8 = (r3 + numDefine4) | 0;
                        r8 = (r6 - r8) | 0;
                        r8 = r8 & numDefine15;
                        r8 = (r3 + r8) | 0;
                        r9 = (r8 + numDefine4) | 0;
                        r8 = r8 >> numDefine2;
                        heapClassInst.heap32[r8] = r3;
                        r3 = r9;
                    }
                } else {
                    r3 = 0;
                }
                r8 = (r2 + numDefine20) | 0;
                if (r4 < 1) {
                    r6 = r8 >> numDefine2;
                    r9 = heapClassInst.heap32[r6];
                } else {
                    repeat26:
                    while (true) {
                        r9 = r8 >> numDefine2;
                        r9 = heapClassInst.heap32[r9];
                        r10 = r6 << numDefine2;
                        r11 = (r9 + r10) | 0;
                        r11 = r11 >> numDefine2;
                        r10 = (r3 + r10) | 0;
                        r11 = heapClassInst.heap32[r11];
                        r6 = (r6 + 1) | 0;
                        r10 = r10 >> numDefine2;
                        heapClassInst.heap32[r10] = r11;
                        if (!(r4 != r6)) {
                            break repeat26;
                        }
                    }
                    r8 = (r2 + numDefine20) | 0;
                }
                if (r9 != 0) {
                    r6 = heapClassInst.heapU8[r2 + numDefine24];
                    if (r6 != 0) {
                        r4 = gNumAlignedFree;
                        r4 = r4 >> numDefine2;
                        r6 = heapClassInst.heap32[r4];
                        r6 = (r6 + 1) | 0;
                        r9 = r9 >> numDefine2;
                        heapClassInst.heap32[r4] = r6;
                        r4 = heapClassInst.heap32[r9 + -1];
                        heapClassInst.heap32[g0] = r4;
                        free(i7);
                        r4 = heapClassInst.heap32[r1 + numDefine3];
                    }
                    r6 = r8 >> numDefine2;
                    heapClassInst.heap32[r6] = 0;
                }
                r6 = r8 >> numDefine2;
                heapClassInst.heap8[r2 + numDefine24] = (byte) r5;
                heapClassInst.heap32[r6] = r3;
                heapClassInst.heap32[r1 + numDefine4] = r7;
            }
        }
        r2 = r4 << numDefine2;
        r3 = heapClassInst.heap32[r1 + numDefine5];
        r2 = (r3 + r2) | 0;
        r2 = r2 >> numDefine2;
        heapClassInst.heap32[r2] = r0;
        r2 = heapClassInst.heap32[r1 + numDefine3];
        r2 = (r2 + 1) | 0;
        heapClassInst.heap32[r1 + numDefine3] = r2;
        commonVariable.rg0 = r0;
        
    }

    public static void zn21btCollisionDispatcher13clearManifoldEP20btPersistentManifold(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int label = 0;
        i7 = sp + 0;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp + 1];
        r0 = r0 >> numDefine2;
        r1 = heapClassInst.heap32[r0 + numDefine279];
        if (!(r1 < 1)) {
            r2 = 0;
            repeat3:
            while (true) {
                r2 = (r2 + 1) | 0;
                if (r1 > r2) {
                    continue repeat3;
                } else {
                    break repeat3;
                }
            }
        }
        heapClassInst.heap32[r0 + numDefine279] = 0;
        
    }

    public static void zn21btCollisionDispatcher14needsCollisionEP17btCollisionObjectS1(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int label = 0;
        i7 = sp + numDefineNeg16;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp + 1];
        if (r0 != 0) {
            r1 = heapClassInst.heap32[fp + numDefine2];
            if (r1 != 0) {
                r2 = heapClassInst.heap32[fp];
                r2 = r2 >> numDefine2;
                r3 = heapClassInst.heap32[r2 + 1];
                r4 = r3 & 1;
                if (!(r4 != 0)) {
                    r4 = heapClassInst.heapU8[r0 + numDefine204];
                    r4 = r4 & numDefine3;
                    if (!(r4 == 0)) {
                        r4 = heapClassInst.heapU8[r1 + numDefine204];
                        r4 = r4 & numDefine3;
                        if (!(r4 == 0)) {
                            r3 = r3 | 1;
                            heapClassInst.heap32[r2 + 1] = r3;
                            r2 = twoEStr977;
                            heapClassInst.heap32[g0] = r2;
                            System.out.println(i7);
                        }
                    }
                }
                r2 = r0 >> numDefine2;
                r3 = heapClassInst.heap32[r2 + numDefine54];
                if (r3 == numDefine2) {
                    label = numDefine10;
                } else {
                    if (r3 != numDefine5) {
                        label = numDefine12;
                    } else {
                        label = numDefine10;
                    }
                }
                repeat12:
                do {
                    if (label == numDefine10) {
                        r3 = r1 >> numDefine2;
                        r3 = heapClassInst.heap32[r3 + numDefine54];
                        if (!(r3 == numDefine2)) {
                            if (!(r3 == numDefine5)) {
                                break repeat12;
                            }
                        }
                        r0 = 0;
                        commonVariable.rg0 = r0;
                        
                    }
                } while (false);
                r3 = heapClassInst.heap32[r2 + numDefine63];
                if (r3 != 0) {
                    r2 = heapClassInst.heap32[r2];
                    r2 = r2 >> numDefine2;
                    r2 = heapClassInst.heap32[r2];
                    heapClassInst.heap32[g0] = r0;
                    heapClassInst.heap32[g0 + 1] = r1;
                    r0 = 0;
                    functionTable.get(r2 >> numDefine2).accept(i7);
                    r0 = commonVariable.rg0 == r0 ? 1 : 0;
                } else {
                    r0 = 0;
                }
                r0 = r0 & 1;
                r0 = r0 ^ 1;
                commonVariable.rg0 = r0;
                
            } else {
                r0 = twoEStr876;
                r1 = twoEStr573;
                heapClassInst.heap32[g0] = r0;
                heapClassInst.heap32[g0 + 1] = r1;
                heapClassInst.heap32[g0 + numDefine2] = numDefine167;
                assertNew(i7);
            }
        } else {
            r0 = twoEStr775;
            r1 = twoEStr573;
            heapClassInst.heap32[g0] = r0;
            heapClassInst.heap32[g0 + 1] = r1;
            heapClassInst.heap32[g0 + numDefine2] = numDefine166;
            assertNew(i7);
        }
        
    }

    public static void zn21btCollisionDispatcher26allocateCollisionAlgorithmEi(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int label = 0;
        i7 = sp + numDefineNeg16;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r0 = r0 >> numDefine2;
        r0 = heapClassInst.heap32[r0 + numDefine48];
        r0 = r0 >> numDefine2;
        r1 = heapClassInst.heap32[r0 + numDefine2];
        r2 = heapClassInst.heap32[fp + 1];
        if (r1 == 0) {
            r0 = gNumAlignedAllocs;
            r0 = r0 >> numDefine2;
            r1 = heapClassInst.heap32[r0];
            r1 = (r1 + 1) | 0;
            heapClassInst.heap32[r0] = r1;
            r0 = (r2 + numDefine19) | 0;
            heapClassInst.heap32[g0] = r0;
            mallocNew(i7);
            r0 = commonVariable.rg0;
            if (!(r0 == 0)) {
                r1 = 0;
                r2 = (r0 + numDefine4) | 0;
                r1 = (r1 - r2) | 0;
                r1 = r1 & numDefine15;
                r1 = (r0 + r1) | 0;
                r2 = r1 >> numDefine2;
                heapClassInst.heap32[r2] = r0;
                r0 = (r1 + numDefine4) | 0;
            }
            commonVariable.rg0 = r0;
            
        } else {
            if (!(r2 == 0)) {
                r3 = heapClassInst.heap32[r0];
                if (!(r3 >= r2)) {
                    r0 = twoEStr270;
                    r1 = twoEStr169;
                    heapClassInst.heap32[g0] = r0;
                    heapClassInst.heap32[g0 + 1] = r1;
                    heapClassInst.heap32[g0 + numDefine2] = numDefine69;
                    assertNew(i7);
                }
            }
            if (r1 > 0) {
                r2 = heapClassInst.heap32[r0 + numDefine3];
                r3 = r2 >> numDefine2;
                r3 = heapClassInst.heap32[r3];
                r1 = (r1 + -1) | 0;
                heapClassInst.heap32[r0 + numDefine3] = r3;
                heapClassInst.heap32[r0 + numDefine2] = r1;
                commonVariable.rg0 = r2;
                
            } else {
                r0 = twoEStr371;
                r1 = twoEStr169;
                heapClassInst.heap32[g0] = r0;
                heapClassInst.heap32[g0 + 1] = r1;
                heapClassInst.heap32[g0 + numDefine2] = numDefine70;
                assertNew(i7);
            }
        }
        
    }

    public static void zn17btCollisionObject24checkCollideWithOverrideEPS(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int label = 0;
        i7 = sp + 0;
        int g0 = i7 >> numDefine2;
        r0 = 1;
        commonVariable.rg0 = r0;
        
    }

    public static void zn17btCollisionObject17setCollisionShapeEP16btCollisionShape(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int label = 0;
        i7 = sp + 0;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r0 = r0 >> numDefine2;
        r1 = heapClassInst.heap32[fp + 1];
        heapClassInst.heap32[r0 + numDefine48] = r1;
        heapClassInst.heap32[r0 + numDefine50] = r1;
        
    }

    public static void znk17btCollisionObject28calculateSerializeBufferSizeEv(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int label = 0;
        i7 = sp + 0;
        int g0 = i7 >> numDefine2;
        r0 = numDefine248;
        commonVariable.rg0 = r0;
        
    }

    public static void zn17btCollisionObjectD1Ev(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int label = 0;
        i7 = sp + 0;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = ztv17btCollisionObject;
        r0 = r0 >> numDefine2;
        r1 = (r1 + numDefine8) | 0;
        heapClassInst.heap32[r0] = r1;
        
    }

    public static void zn17btCollisionObjectD0Ev(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int label = 0;
        i7 = sp + numDefineNeg8;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = ztv17btCollisionObject;
        r2 = r0 >> numDefine2;
        r1 = (r1 + numDefine8) | 0;
        heapClassInst.heap32[r2] = r1;
        if (!(r0 == 0)) {
            r0 = gNumAlignedFree;
            r0 = r0 >> numDefine2;
            r1 = heapClassInst.heap32[r0];
            r1 = (r1 + 1) | 0;
            heapClassInst.heap32[r0] = r1;
            r0 = heapClassInst.heap32[r2 + -1];
            heapClassInst.heap32[g0] = r0;
            free(i7);
        }
        
    }

    public static void znk17btCollisionObject9serializeEPvP12btSerializer(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        int r6 = 0;
        int label = 0;
        i7 = sp + numDefineNeg8;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = heapClassInst.heap32[fp + 1];
        r2 = r0 >> numDefine2;
        r1 = r1 >> numDefine2;
        heapClassInst.heap32[r1 + numDefine4] = heapClassInst.heap32[r2 + 1];
        heapClassInst.heap32[r1 + numDefine5] = heapClassInst.heap32[r2 + numDefine2];
        heapClassInst.heap32[r1 + numDefine6] = heapClassInst.heap32[r2 + numDefine3];
        heapClassInst.heap32[r1 + numDefine7] = heapClassInst.heap32[r2 + numDefine4];
        heapClassInst.heap32[r1 + numDefine8] = heapClassInst.heap32[r2 + numDefine5];
        heapClassInst.heap32[r1 + numDefine9] = heapClassInst.heap32[r2 + numDefine6];
        heapClassInst.heap32[r1 + numDefine10] = heapClassInst.heap32[r2 + numDefine7];
        heapClassInst.heap32[r1 + numDefine11] = heapClassInst.heap32[r2 + numDefine8];
        heapClassInst.heap32[r1 + numDefine12] = heapClassInst.heap32[r2 + numDefine9];
        heapClassInst.heap32[r1 + numDefine13] = heapClassInst.heap32[r2 + numDefine10];
        heapClassInst.heap32[r1 + numDefine14] = heapClassInst.heap32[r2 + numDefine11];
        heapClassInst.heap32[r1 + numDefine15] = heapClassInst.heap32[r2 + numDefine12];
        heapClassInst.heap32[r1 + numDefine16] = heapClassInst.heap32[r2 + numDefine13];
        heapClassInst.heap32[r1 + numDefine17] = heapClassInst.heap32[r2 + numDefine14];
        heapClassInst.heap32[r1 + numDefine18] = heapClassInst.heap32[r2 + numDefine15];
        heapClassInst.heap32[r1 + numDefine19] = heapClassInst.heap32[r2 + numDefine16];
        heapClassInst.heap32[r1 + numDefine20] = heapClassInst.heap32[r2 + numDefine17];
        heapClassInst.heap32[r1 + numDefine21] = heapClassInst.heap32[r2 + numDefine18];
        heapClassInst.heap32[r1 + numDefine22] = heapClassInst.heap32[r2 + numDefine19];
        heapClassInst.heap32[r1 + numDefine23] = heapClassInst.heap32[r2 + numDefine20];
        heapClassInst.heap32[r1 + numDefine24] = heapClassInst.heap32[r2 + numDefine21];
        heapClassInst.heap32[r1 + numDefine25] = heapClassInst.heap32[r2 + numDefine22];
        heapClassInst.heap32[r1 + numDefine26] = heapClassInst.heap32[r2 + numDefine23];
        heapClassInst.heap32[r1 + numDefine27] = heapClassInst.heap32[r2 + numDefine24];
        heapClassInst.heap32[r1 + numDefine28] = heapClassInst.heap32[r2 + numDefine25];
        heapClassInst.heap32[r1 + numDefine29] = heapClassInst.heap32[r2 + numDefine26];
        heapClassInst.heap32[r1 + numDefine30] = heapClassInst.heap32[r2 + numDefine27];
        heapClassInst.heap32[r1 + numDefine31] = heapClassInst.heap32[r2 + numDefine28];
        heapClassInst.heap32[r1 + numDefine32] = heapClassInst.heap32[r2 + numDefine29];
        heapClassInst.heap32[r1 + numDefine33] = heapClassInst.heap32[r2 + numDefine30];
        heapClassInst.heap32[r1 + numDefine34] = heapClassInst.heap32[r2 + numDefine31];
        heapClassInst.heap32[r1 + numDefine35] = heapClassInst.heap32[r2 + numDefine32];
        heapClassInst.heap32[r1 + numDefine36] = heapClassInst.heap32[r2 + numDefine33];
        heapClassInst.heap32[r1 + numDefine37] = heapClassInst.heap32[r2 + numDefine34];
        heapClassInst.heap32[r1 + numDefine38] = heapClassInst.heap32[r2 + numDefine35];
        heapClassInst.heap32[r1 + numDefine39] = heapClassInst.heap32[r2 + numDefine36];
        heapClassInst.heap32[r1 + numDefine40] = heapClassInst.heap32[r2 + numDefine37];
        heapClassInst.heap32[r1 + numDefine41] = heapClassInst.heap32[r2 + numDefine38];
        heapClassInst.heap32[r1 + numDefine42] = heapClassInst.heap32[r2 + numDefine39];
        heapClassInst.heap32[r1 + numDefine43] = heapClassInst.heap32[r2 + numDefine40];
        heapClassInst.heap32[r1 + numDefine44] = heapClassInst.heap32[r2 + numDefine41];
        heapClassInst.heap32[r1 + numDefine45] = heapClassInst.heap32[r2 + numDefine42];
        heapClassInst.heap32[r1 + numDefine46] = heapClassInst.heap32[r2 + numDefine43];
        heapClassInst.heap32[r1 + numDefine47] = heapClassInst.heap32[r2 + numDefine44];
        r3 = heapClassInst.heap32[r2 + numDefine45];
        heapClassInst.heap32[r1 + numDefine55] = r3;
        r3 = heapClassInst.heap32[fp + numDefine2];
        heapClassInst.heap32[r1 + numDefine48] = heapClassInst.heap32[r2 + numDefine46];
        heapClassInst.heap32[r1] = 0;
        r4 = r3 >> numDefine2;
        r5 = heapClassInst.heap32[r4];
        r5 = r5 >> numDefine2;
        r5 = heapClassInst.heap32[r5 + numDefine7];
        r6 = heapClassInst.heap32[r2 + numDefine48];
        heapClassInst.heap32[g0] = r3;
        heapClassInst.heap32[g0 + 1] = r6;
        functionTable.get(r5 >> numDefine2).accept(i7);
        heapClassInst.heap32[r1 + 1] = commonVariable.rg0;
        heapClassInst.heap32[r1 + numDefine2] = 0;
        r5 = heapClassInst.heap32[r2 + numDefine51];
        heapClassInst.heap32[r1 + numDefine56] = r5;
        r5 = heapClassInst.heap32[r2 + numDefine52];
        heapClassInst.heap32[r1 + numDefine57] = r5;
        r5 = heapClassInst.heap32[r2 + numDefine53];
        heapClassInst.heap32[r1 + numDefine58] = r5;
        r5 = heapClassInst.heap32[r2 + numDefine54];
        heapClassInst.heap32[r1 + numDefine59] = r5;
        r5 = heapClassInst.heap32[r2 + numDefine54];
        heapClassInst.heap32[r1 + numDefine59] = r5;
        heapClassInst.heap32[r1 + numDefine49] = heapClassInst.heap32[r2 + numDefine55];
        heapClassInst.heap32[r1 + numDefine50] = heapClassInst.heap32[r2 + numDefine56];
        heapClassInst.heap32[r1 + numDefine51] = heapClassInst.heap32[r2 + numDefine57];
        r5 = heapClassInst.heap32[r2 + numDefine58];
        heapClassInst.heap32[r1 + numDefine60] = r5;
        r5 = heapClassInst.heap32[r4];
        r5 = r5 >> numDefine2;
        r5 = heapClassInst.heap32[r5 + numDefine10];
        heapClassInst.heap32[g0] = r3;
        heapClassInst.heap32[g0 + 1] = r0;
        functionTable.get(r5 >> numDefine2).accept(i7);
        r0 = commonVariable.rg0;
        r5 = heapClassInst.heap32[r4];
        r5 = r5 >> numDefine2;
        r5 = heapClassInst.heap32[r5 + numDefine7];
        heapClassInst.heap32[g0] = r3;
        heapClassInst.heap32[g0 + 1] = r0;
        functionTable.get(r5 >> numDefine2).accept(i7);
        r5 = commonVariable.rg0;
        heapClassInst.heap32[r1 + numDefine3] = r5;
        if (!(r5 == 0)) {
            r4 = heapClassInst.heap32[r4];
            r4 = r4 >> numDefine2;
            r4 = heapClassInst.heap32[r4 + numDefine12];
            heapClassInst.heap32[g0] = r3;
            heapClassInst.heap32[g0 + 1] = r0;
            functionTable.get(r4 >> numDefine2).accept(i7);
        }
        heapClassInst.heap32[r1 + numDefine52] = heapClassInst.heap32[r2 + numDefine60];
        heapClassInst.heap32[r1 + numDefine53] = heapClassInst.heap32[r2 + numDefine61];
        heapClassInst.heap32[r1 + numDefine54] = heapClassInst.heap32[r2 + numDefine62];
        heapClassInst.heap32[r1 + numDefine54] = heapClassInst.heap32[r2 + numDefine62];
        r0 = heapClassInst.heap32[r2 + numDefine63];
        heapClassInst.heap32[r1 + numDefine61] = r0;
        r0 = twoEStr78;
        commonVariable.rg0 = r0;
        
    }

    public static void znk17btCollisionObject21serializeSingleObjectEP12btSerializer(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        int label = 0;
        i7 = sp + numDefineNeg24;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = r0 >> numDefine2;
        r2 = heapClassInst.heap32[r1];
        r2 = r2 >> numDefine2;
        r2 = heapClassInst.heap32[r2 + numDefine4];
        heapClassInst.heap32[g0] = r0;
        r3 = heapClassInst.heap32[fp + 1];
        functionTable.get(r2 >> numDefine2).accept(i7);
        r4 = r3 >> numDefine2;
        r5 = heapClassInst.heap32[r4];
        r5 = r5 >> numDefine2;
        r5 = heapClassInst.heap32[r5 + numDefine4];
        heapClassInst.heap32[g0] = r3;
        heapClassInst.heap32[g0 + 1] = commonVariable.rg0;
        heapClassInst.heap32[g0 + numDefine2] = 1;
        functionTable.get(r5 >> numDefine2).accept(i7);
        r2 = commonVariable.rg0;
        r1 = heapClassInst.heap32[r1];
        r1 = r1 >> numDefine2;
        r5 = r2 >> numDefine2;
        r1 = heapClassInst.heap32[r1 + numDefine5];
        r5 = heapClassInst.heap32[r5 + numDefine2];
        heapClassInst.heap32[g0] = r0;
        heapClassInst.heap32[g0 + 1] = r5;
        heapClassInst.heap32[g0 + numDefine2] = r3;
        functionTable.get(r1 >> numDefine2).accept(i7);
        r4 = heapClassInst.heap32[r4];
        r4 = r4 >> numDefine2;
        r4 = heapClassInst.heap32[r4 + numDefine5];
        heapClassInst.heap32[g0] = r3;
        heapClassInst.heap32[g0 + 1] = r2;
        heapClassInst.heap32[g0 + numDefine2] = commonVariable.rg0;
        heapClassInst.heap32[g0 + numDefine3] = (int) numDefine59651;
        heapClassInst.heap32[g0 + numDefine4] = r0;
        functionTable.get(r4 >> numDefine2).accept(i7);
        
    }

    public static void zn16btManifoldResult20setShapeIdentifiersAEii(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int label = 0;
        i7 = sp + 0;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r0 = r0 >> numDefine2;
        r1 = heapClassInst.heap32[fp + 1];
        r2 = heapClassInst.heap32[fp + numDefine2];
        heapClassInst.heap32[r0 + numDefine36] = r1;
        heapClassInst.heap32[r0 + numDefine38] = r2;
        
    }

    public static void zn16btManifoldResult20setShapeIdentifiersBEii(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int label = 0;
        i7 = sp + 0;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r0 = r0 >> numDefine2;
        r1 = heapClassInst.heap32[fp + 1];
        r2 = heapClassInst.heap32[fp + numDefine2];
        heapClassInst.heap32[r0 + numDefine37] = r1;
        heapClassInst.heap32[r0 + numDefine39] = r2;
        
    }

    public static void zn16btCollisionWorld14setDebugDrawerEP12btIDebugDraw(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int label = 0;
        i7 = sp + 0;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r0 = r0 >> numDefine2;
        r1 = heapClassInst.heap32[fp + 1];
        heapClassInst.heap32[r0 + numDefine21] = r1;
        
    }

    public static void zn16btCollisionWorld14getDebugDrawerEv(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int label = 0;
        i7 = sp + 0;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r0 = r0 >> numDefine2;
        r0 = heapClassInst.heap32[r0 + numDefine21];
        commonVariable.rg0 = r0;
        
    }

    public static void znk16btCollisionWorld20ConvexResultCallback14needsCollisionEP17btBroadphaseProxy(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int label = 0;
        i7 = sp + 0;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = heapClassInst.heap32[fp + 1];
        r2 = heapClassInst.heapU16[(r0 + numDefine10) >> 1];
        r3 = heapClassInst.heapU16[(r1 + numDefine4) >> 1];
        r2 = r2 & r3;
        r2 = r2 & numDefine65535;
        if (r2 == 0) {
            r0 = 0;
            commonVariable.rg0 = r0;
            
        } else {
            r1 = heapClassInst.heapU16[(r1 + numDefine6) >> 1];
            r0 = heapClassInst.heapU16[(r0 + numDefine8) >> 1];
            r0 = r1 & r0;
            r0 = r0 & numDefine65535;
            r1 = 0;
            r0 = r0 != r1 ? 1 : 0;
            r0 = r0 & 1;
            commonVariable.rg0 = r0;
            
        }
    }

    public static void zn12btConvexCast10CastResult9DebugDrawEf(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int label = 0;
        i7 = sp + 0;
        int g0 = i7 >> numDefine2;
        
    }

    public static void zn12btConvexCast10CastResult15drawCoordSystemERK11btTransform(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int label = 0;
        i7 = sp + 0;
        int g0 = i7 >> numDefine2;
        
    }

    public static void zn12btConvexCast10CastResultD1Ev(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int label = 0;
        i7 = sp + 0;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = ztvn12btConvexCast10CastResultE;
        r0 = r0 >> numDefine2;
        r1 = (r1 + numDefine8) | 0;
        heapClassInst.heap32[r0] = r1;
        
    }

    public static void zn12btConvexCast10CastResultD0Ev(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int label = 0;
        i7 = sp + numDefineNeg8;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = ztvn12btConvexCast10CastResultE;
        r2 = r0 >> numDefine2;
        r1 = (r1 + numDefine8) | 0;
        heapClassInst.heap32[r2] = r1;
        heapClassInst.heap32[g0] = r0;
        zdlPv(i7);
        
    }

    public static void zzn16btCollisionWorldResultCallback(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        float f0 = 0.0F;
        float f1 = 0.0F;
        float f2 = 0.0F;
        float f3 = 0.0F;
        float f4 = 0.0F;
        float f5 = 0.0F;
        float f6 = 0.0F;
        float f7 = 0.0F;
        float f8 = 0.0F;
        float f9 = 0.0F;
        float f10 = 0.0F;
        float f11 = 0.0F;
        int label = 0;
        i7 = sp + numDefineNeg56;
        int g0 = i7 >> numDefine2;
        r0 = sp + numDefineNeg8;
        r1 = heapClassInst.heap32[fp + numDefine3];
        r2 = heapClassInst.heap32[fp + 1];
        r3 = heapClassInst.heap32[fp];
        r4 = r0 >> numDefine2;
        r5 = heapClassInst.heap32[fp + numDefine4];
        heapClassInst.heap32[fp + numDefineNeg2] = r1;
        r1 = r2 >> numDefine2;
        heapClassInst.heap32[r4 + 1] = r5;
        r2 = r3 >> numDefine2;
        r3 = heapClassInst.heap32[r2 + numDefine12];
        f0 = heapClassInst.heapFloat[r2 + numDefine22];
        f1 = heapClassInst.heapFloat[r1];
        f2 = heapClassInst.heapFloat[r2 + numDefine18];
        f3 = heapClassInst.heapFloat[r2 + numDefine14];
        f4 = heapClassInst.heapFloat[r2 + numDefine23];
        f5 = heapClassInst.heapFloat[r1 + 1];
        f6 = heapClassInst.heapFloat[r2 + numDefine19];
        f7 = heapClassInst.heapFloat[r2 + numDefine15];
        f8 = heapClassInst.heapFloat[r2 + numDefine24];
        f9 = heapClassInst.heapFloat[r1 + numDefine2];
        f10 = heapClassInst.heapFloat[r2 + numDefine20];
        f11 = heapClassInst.heapFloat[r2 + numDefine16];
        r1 = sp + numDefineNeg40;
        f3 = f3 * f1;
        f7 = f7 * f5;
        r4 = r1 >> numDefine2;
        heapClassInst.heap32[fp + numDefineNeg10] = r3;
        f2 = f2 * f1;
        f6 = f6 * f5;
        f3 = f3 + f7;
        f7 = f11 * f9;
        f0 = f0 * f1;
        f1 = f4 * f5;
        f2 = f2 + f6;
        f4 = f10 * f9;
        f3 = f3 + f7;
        heapClassInst.heap32[r4 + 1] = r0;
        f0 = f0 + f1;
        f1 = f8 * f9;
        f2 = f2 + f4;
        heapClassInst.heapFloat[r4 + numDefine2] = f3;
        f0 = f0 + f1;
        heapClassInst.heapFloat[r4 + numDefine3] = f2;
        heapClassInst.heapFloat[r4 + numDefine4] = f0;
        heapClassInst.heap32[r4 + numDefine5] = 0;
        heapClassInst.heap32[r4 + numDefine6] = heapClassInst.heap32[fp + numDefine2];
        r0 = heapClassInst.heap32[r2 + numDefine11];
        r2 = r0 >> numDefine2;
        r2 = heapClassInst.heap32[r2];
        r2 = r2 >> numDefine2;
        r2 = heapClassInst.heap32[r2 + numDefine3];
        heapClassInst.heap32[g0] = r0;
        heapClassInst.heap32[g0 + 1] = r1;
        heapClassInst.heap32[g0 + numDefine2] = 1;
        functionTable.get(r2 >> numDefine2).accept(i7);
        
    }

    public static void zzn16btCollisionWorldTestSingERK(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        float f0 = 0.0F;
        float f1 = 0.0F;
        float f2 = 0.0F;
        float f3 = 0.0F;
        float f4 = 0.0F;
        float f5 = 0.0F;
        float f6 = 0.0F;
        float f7 = 0.0F;
        float f8 = 0.0F;
        float f9 = 0.0F;
        float f10 = 0.0F;
        float f11 = 0.0F;
        int label = 0;
        i7 = sp + numDefineNeg56;
        int g0 = i7 >> numDefine2;
        r0 = sp + numDefineNeg8;
        r1 = heapClassInst.heap32[fp + numDefine3];
        r2 = heapClassInst.heap32[fp + 1];
        r3 = heapClassInst.heap32[fp];
        r4 = r0 >> numDefine2;
        r5 = heapClassInst.heap32[fp + numDefine4];
        heapClassInst.heap32[fp + numDefineNeg2] = r1;
        r1 = r2 >> numDefine2;
        heapClassInst.heap32[r4 + 1] = r5;
        r2 = r3 >> numDefine2;
        r3 = heapClassInst.heap32[r2 + numDefine12];
        f0 = heapClassInst.heapFloat[r2 + numDefine22];
        f1 = heapClassInst.heapFloat[r1];
        f2 = heapClassInst.heapFloat[r2 + numDefine18];
        f3 = heapClassInst.heapFloat[r2 + numDefine14];
        f4 = heapClassInst.heapFloat[r2 + numDefine23];
        f5 = heapClassInst.heapFloat[r1 + 1];
        f6 = heapClassInst.heapFloat[r2 + numDefine19];
        f7 = heapClassInst.heapFloat[r2 + numDefine15];
        f8 = heapClassInst.heapFloat[r2 + numDefine24];
        f9 = heapClassInst.heapFloat[r1 + numDefine2];
        f10 = heapClassInst.heapFloat[r2 + numDefine20];
        f11 = heapClassInst.heapFloat[r2 + numDefine16];
        r1 = sp + numDefineNeg40;
        f3 = f3 * f1;
        f7 = f7 * f5;
        r4 = r1 >> numDefine2;
        heapClassInst.heap32[fp + numDefineNeg10] = r3;
        f2 = f2 * f1;
        f6 = f6 * f5;
        f3 = f3 + f7;
        f7 = f11 * f9;
        f0 = f0 * f1;
        f1 = f4 * f5;
        f2 = f2 + f6;
        f4 = f10 * f9;
        f3 = f3 + f7;
        heapClassInst.heap32[r4 + 1] = r0;
        f0 = f0 + f1;
        f1 = f8 * f9;
        f2 = f2 + f4;
        heapClassInst.heapFloat[r4 + numDefine2] = f3;
        f0 = f0 + f1;
        heapClassInst.heapFloat[r4 + numDefine3] = f2;
        heapClassInst.heapFloat[r4 + numDefine4] = f0;
        heapClassInst.heap32[r4 + numDefine5] = 0;
        heapClassInst.heap32[r4 + numDefine6] = heapClassInst.heap32[fp + numDefine2];
        r0 = heapClassInst.heap32[r2 + numDefine11];
        r2 = r0 >> numDefine2;
        r2 = heapClassInst.heap32[r2];
        r2 = r2 >> numDefine2;
        r2 = heapClassInst.heap32[r2 + numDefine3];
        heapClassInst.heap32[g0] = r0;
        heapClassInst.heap32[g0 + 1] = r1;
        heapClassInst.heap32[g0 + numDefine2] = 1;
        functionTable.get(r2 >> numDefine2).accept(i7);
        
    }

    public static void zzn16btCollisionWorld13rayTestSingleERK11btTransformS2P17btCollisionObjectPK16btCollisionShapeS2RNS17RayResultCallbackEEN15LocalInfoAdder2D1Ev(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int label = 0;
        i7 = sp + 0;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = ztvzn16btCollisionWorld13rayTestSingleERK11btTransformS2P17btCollisionObjectPK16btCollisionShapeS2RNS17RayResultCallbackEE15LocalInfoAdder2;
        r0 = r0 >> numDefine2;
        r1 = (r1 + numDefine8) | 0;
        heapClassInst.heap32[r0] = r1;
        
    }

    public static void zzn16btCollisionWorld13rayTestSingleERK11btTransformS2P17btCollisionObjectPK16btCollisionShapeS2RNS17RayResultCallbackEEN15LocalInfoAdder2D0Ev(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int label = 0;
        i7 = sp + numDefineNeg8;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = ztvzn16btCollisionWorld13rayTestSingleERK11btTransformS2P17btCollisionObjectPK16btCollisionShapeS2RNS17RayResultCallbackEE15LocalInfoAdder2;
        r2 = r0 >> numDefine2;
        r1 = (r1 + numDefine8) | 0;
        heapClassInst.heap32[r2] = r1;
        heapClassInst.heap32[g0] = r0;
        zdlPv(i7);
        
    }

    public static void zzn16btCollisionWorldTest(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        int label = 0;
        i7 = sp + numDefineNeg24;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = sp + numDefineNeg8;
        r0 = r0 >> numDefine2;
        heapClassInst.heap32[fp + numDefineNeg2] = -1;
        r2 = heapClassInst.heap32[fp + 1];
        r3 = r1 >> numDefine2;
        r4 = heapClassInst.heap32[r0 + numDefine6];
        r5 = r2 >> numDefine2;
        heapClassInst.heap32[r3 + 1] = r4;
        r3 = heapClassInst.heap32[r5 + 1];
        if (!(r3 != 0)) {
            heapClassInst.heap32[r5 + 1] = r1;
        }
        r1 = heapClassInst.heap32[fp + numDefine2];
        r3 = heapClassInst.heap32[r0 + numDefine5];
        r4 = r3 >> numDefine2;
        r4 = heapClassInst.heap32[r4];
        r4 = r4 >> numDefine2;
        r4 = heapClassInst.heap32[r4 + numDefine3];
        heapClassInst.heap32[g0] = r3;
        heapClassInst.heap32[g0 + 1] = r2;
        heapClassInst.heap32[g0 + numDefine2] = r1;
        functionTable.get(r4 >> numDefine2).accept(i7);
        r1 = heapClassInst.heap32[r0 + numDefine5];
        r1 = r1 >> numDefine2;
        heapClassInst.heap32[r0 + 1] = heapClassInst.heap32[r1 + 1];
        
    }

    public static void zn16btWorldQuerySingTransformObject(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        int r6 = 0;
        int r7 = 0;
        float f0 = 0.0F;
        float f1 = 0.0F;
        int label = 0;
        i7 = sp + numDefineNeg72;
        int g0 = i7 >> numDefine2;
        r0 = sp + numDefineNeg8;
        r1 = heapClassInst.heap32[fp + numDefine4];
        r2 = heapClassInst.heap32[fp];
        r3 = r0 >> numDefine2;
        r4 = heapClassInst.heap32[fp + numDefine5];
        heapClassInst.heap32[fp + numDefineNeg2] = r1;
        r1 = r2 >> numDefine2;
        heapClassInst.heap32[r3 + 1] = r4;
        r2 = heapClassInst.heap32[r1 + numDefine52];
        f0 = heapClassInst.heapFloat[fp + numDefine3];
        r3 = r2 >> numDefine2;
        f1 = heapClassInst.heapFloat[r3 + 1];
        if (f1 < f0) {
            commonVariable.fg0 = f0;
            
        } else {
            r4 = heapClassInst.heap32[fp + 1];
            r5 = heapClassInst.heap32[fp + numDefine2];
            r1 = heapClassInst.heap32[r1 + numDefine53];
            r6 = sp + numDefineNeg56;
            r7 = r6 >> numDefine2;
            heapClassInst.heap32[fp + numDefineNeg14] = r1;
            r1 = r4 >> numDefine2;
            heapClassInst.heap32[r7 + 1] = r0;
            heapClassInst.heap32[r7 + numDefine2] = heapClassInst.heap32[r1];
            heapClassInst.heap32[r7 + numDefine3] = heapClassInst.heap32[r1 + 1];
            heapClassInst.heap32[r7 + numDefine4] = heapClassInst.heap32[r1 + numDefine2];
            r0 = r5 >> numDefine2;
            heapClassInst.heap32[r7 + numDefine5] = heapClassInst.heap32[r1 + numDefine3];
            heapClassInst.heap32[r7 + numDefine6] = heapClassInst.heap32[r0];
            heapClassInst.heap32[r7 + numDefine7] = heapClassInst.heap32[r0 + 1];
            heapClassInst.heap32[r7 + numDefine8] = heapClassInst.heap32[r0 + numDefine2];
            heapClassInst.heap32[r7 + numDefine9] = heapClassInst.heap32[r0 + numDefine3];
            heapClassInst.heapFloat[r7 + numDefine10] = f0;
            r0 = heapClassInst.heap32[r3];
            r0 = r0 >> numDefine2;
            r0 = heapClassInst.heap32[r0 + numDefine3];
            heapClassInst.heap32[g0] = r2;
            heapClassInst.heap32[g0 + 1] = r6;
            heapClassInst.heap32[g0 + numDefine2] = 1;
            functionTable.get(r0 >> numDefine2).accept(i7);
            
        }
    }

    public static void zn16btWorldQuerySingTransform(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        int r6 = 0;
        int r7 = 0;
        float f0 = 0.0F;
        float f1 = 0.0F;
        int label = 0;
        i7 = sp + numDefineNeg72;
        int g0 = i7 >> numDefine2;
        r0 = sp + numDefineNeg8;
        r1 = heapClassInst.heap32[fp + numDefine4];
        r2 = heapClassInst.heap32[fp];
        r3 = r0 >> numDefine2;
        r4 = heapClassInst.heap32[fp + numDefine5];
        heapClassInst.heap32[fp + numDefineNeg2] = r1;
        r1 = r2 >> numDefine2;
        heapClassInst.heap32[r3 + 1] = r4;
        r2 = heapClassInst.heap32[r1 + numDefine52];
        f0 = heapClassInst.heapFloat[fp + numDefine3];
        r3 = r2 >> numDefine2;
        f1 = heapClassInst.heapFloat[r3 + 1];
        if (f1 < f0) {
            commonVariable.fg0 = f0;
            
        } else {
            r4 = heapClassInst.heap32[fp + 1];
            r5 = heapClassInst.heap32[fp + numDefine2];
            r1 = heapClassInst.heap32[r1 + numDefine53];
            r6 = sp + numDefineNeg56;
            r7 = r6 >> numDefine2;
            heapClassInst.heap32[fp + numDefineNeg14] = r1;
            r1 = r4 >> numDefine2;
            heapClassInst.heap32[r7 + 1] = r0;
            heapClassInst.heap32[r7 + numDefine2] = heapClassInst.heap32[r1];
            heapClassInst.heap32[r7 + numDefine3] = heapClassInst.heap32[r1 + 1];
            heapClassInst.heap32[r7 + numDefine4] = heapClassInst.heap32[r1 + numDefine2];
            r0 = r5 >> numDefine2;
            heapClassInst.heap32[r7 + numDefine5] = heapClassInst.heap32[r1 + numDefine3];
            heapClassInst.heap32[r7 + numDefine6] = heapClassInst.heap32[r0];
            heapClassInst.heap32[r7 + numDefine7] = heapClassInst.heap32[r0 + 1];
            heapClassInst.heap32[r7 + numDefine8] = heapClassInst.heap32[r0 + numDefine2];
            heapClassInst.heap32[r7 + numDefine9] = heapClassInst.heap32[r0 + numDefine3];
            heapClassInst.heapFloat[r7 + numDefine10] = f0;
            r0 = heapClassInst.heap32[r3];
            r0 = r0 >> numDefine2;
            r0 = heapClassInst.heap32[r0 + numDefine3];
            heapClassInst.heap32[g0] = r2;
            heapClassInst.heap32[g0 + 1] = r6;
            heapClassInst.heap32[g0 + numDefine2] = 0;
            functionTable.get(r0 >> numDefine2).accept(i7);
            
        }
    }

    public static void zn16btWorldQuerySingbt(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int label = 0;
        i7 = sp + 0;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = ztvzn16CollsionQuerySingObjectPK;
        r0 = r0 >> numDefine2;
        r1 = (r1 + numDefine8) | 0;
        heapClassInst.heap32[r0] = r1;
        
    }

    public static void zn16btWorldQuerySingShape(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int label = 0;
        i7 = sp + numDefineNeg8;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = ztvzn16CollsionQuerySingObjectPK;
        r2 = r0 >> numDefine2;
        r1 = (r1 + numDefine8) | 0;
        heapClassInst.heap32[r2] = r1;
        heapClassInst.heap32[g0] = r0;
        zdlPv(i7);
        
    }

    public static void zn16btWorldQuerySingle(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        int label = 0;
        i7 = sp + numDefineNeg24;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = sp + numDefineNeg8;
        r0 = r0 >> numDefine2;
        heapClassInst.heap32[fp + numDefineNeg2] = -1;
        r2 = heapClassInst.heap32[fp + 1];
        r3 = r1 >> numDefine2;
        r4 = heapClassInst.heap32[r0 + numDefine4];
        r5 = r2 >> numDefine2;
        heapClassInst.heap32[r3 + 1] = r4;
        r3 = heapClassInst.heap32[r5 + 1];
        if (!(r3 != 0)) {
            heapClassInst.heap32[r5 + 1] = r1;
        }
        r1 = heapClassInst.heap32[fp + numDefine2];
        r3 = heapClassInst.heap32[r0 + numDefine3];
        r4 = r3 >> numDefine2;
        r4 = heapClassInst.heap32[r4];
        r4 = r4 >> numDefine2;
        r4 = heapClassInst.heap32[r4 + numDefine3];
        heapClassInst.heap32[g0] = r3;
        heapClassInst.heap32[g0 + 1] = r2;
        heapClassInst.heap32[g0 + numDefine2] = r1;
        functionTable.get(r4 >> numDefine2).accept(i7);
        r1 = heapClassInst.heap32[r0 + numDefine3];
        r1 = r1 >> numDefine2;
        heapClassInst.heap32[r0 + 1] = heapClassInst.heap32[r1 + 1];
        
    }

    public static void zn17DebugDrawcallbackD1Ev(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int label = 0;
        i7 = sp + 0;
        int g0 = i7 >> numDefine2;
        r0 = ztv17DebugDrawcallback;
        r1 = heapClassInst.heap32[fp];
        r1 = r1 >> numDefine2;
        r2 = (r0 + numDefine8) | 0;
        r3 = ztv31btInternalTriangleIndexCallback;
        r0 = (r0 + numDefine32) | 0;
        heapClassInst.heap32[r1] = r2;
        r2 = ztv18btTriangleCallback;
        r3 = (r3 + numDefine8) | 0;
        heapClassInst.heap32[r1 + 1] = r0;
        r0 = (r2 + numDefine8) | 0;
        heapClassInst.heap32[r1 + 1] = r3;
        heapClassInst.heap32[r1] = r0;
        
    }

    public static void zn17DebugDrawcallbackD0Ev(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int label = 0;
        i7 = sp + numDefineNeg8;
        int g0 = i7 >> numDefine2;
        r0 = ztv17DebugDrawcallback;
        r1 = heapClassInst.heap32[fp];
        r2 = r1 >> numDefine2;
        r3 = (r0 + numDefine8) | 0;
        r4 = ztv31btInternalTriangleIndexCallback;
        r0 = (r0 + numDefine32) | 0;
        heapClassInst.heap32[r2] = r3;
        r3 = ztv18btTriangleCallback;
        r4 = (r4 + numDefine8) | 0;
        heapClassInst.heap32[r2 + 1] = r0;
        r0 = (r3 + numDefine8) | 0;
        heapClassInst.heap32[r2 + 1] = r4;
        heapClassInst.heap32[r2] = r0;
        heapClassInst.heap32[g0] = r1;
        zdlPv(i7);
        
    }

    public static void zn17DebugDrawcallback15processTriangleEP9btVector3ii(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        int r6 = 0;
        int r7 = 0;
        int r8 = 0;
        int r9 = 0;
        int r10 = 0;
        float f0 = 0.0F;
        float f1 = 0.0F;
        float f2 = 0.0F;
        float f3 = 0.0F;
        float f4 = 0.0F;
        float f5 = 0.0F;
        float f6 = 0.0F;
        float f7 = 0.0F;
        float f8 = 0.0F;
        float f9 = 0.0F;
        float f10 = 0.0F;
        float f11 = 0.0F;
        float f12 = 0.0F;
        float f13 = 0.0F;
        float f14 = 0.0F;
        float f15 = 0.0F;
        float f16 = 0.0F;
        float f17 = 0.0F;
        float f18 = 0.0F;
        float f19 = 0.0F;
        float f20 = 0.0F;
        float f21 = 0.0F;
        int label = 0;
        i7 = sp + numDefineNeg112;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = heapClassInst.heap32[fp + 1];
        r2 = r0 >> numDefine2;
        r1 = r1 >> numDefine2;
        f0 = heapClassInst.heapFloat[r1];
        f1 = heapClassInst.heapFloat[r2 + numDefine7];
        f2 = heapClassInst.heapFloat[r1 + 1];
        f3 = heapClassInst.heapFloat[r2 + numDefine8];
        f4 = heapClassInst.heapFloat[r2 + numDefine11];
        f5 = heapClassInst.heapFloat[r2 + numDefine12];
        f6 = f1 * f0;
        f7 = f3 * f2;
        f8 = heapClassInst.heapFloat[r1 + numDefine2];
        f9 = heapClassInst.heapFloat[r2 + numDefine9];
        f10 = heapClassInst.heapFloat[r2 + numDefine15];
        f11 = heapClassInst.heapFloat[r2 + numDefine16];
        f12 = heapClassInst.heapFloat[r2 + numDefine13];
        f13 = f4 * f0;
        f14 = f5 * f2;
        f6 = f6 + f7;
        f7 = f9 * f8;
        f15 = heapClassInst.heapFloat[r2 + numDefine17];
        f0 = f10 * f0;
        f2 = f11 * f2;
        f13 = f13 + f14;
        f14 = f12 * f8;
        f6 = f6 + f7;
        f7 = heapClassInst.heapFloat[r2 + numDefine19];
        f16 = heapClassInst.heapFloat[r2 + numDefine21];
        f17 = heapClassInst.heapFloat[r2 + numDefine20];
        r3 = sp + numDefineNeg32;
        f13 = f13 + f14;
        f0 = f0 + f2;
        f2 = f15 * f8;
        f6 = f6 + f7;
        f0 = f0 + f2;
        r4 = r3 >> numDefine2;
        f2 = f13 + f17;
        heapClassInst.heapFloat[fp + numDefineNeg8] = f6;
        f0 = f0 + f16;
        heapClassInst.heapFloat[r4 + 1] = f2;
        heapClassInst.heapFloat[r4 + numDefine2] = f0;
        heapClassInst.heap32[r4 + numDefine3] = 0;
        f8 = heapClassInst.heapFloat[r1 + numDefine4];
        f13 = heapClassInst.heapFloat[r1 + numDefine5];
        f14 = heapClassInst.heapFloat[r1 + numDefine6];
        f18 = f1 * f8;
        f19 = f3 * f13;
        f20 = f4 * f8;
        f21 = f5 * f13;
        f18 = f18 + f19;
        f19 = f9 * f14;
        f18 = f18 + f19;
        f8 = f10 * f8;
        f13 = f11 * f13;
        f19 = f20 + f21;
        f20 = f12 * f14;
        f18 = f18 + f7;
        r4 = sp + numDefineNeg48;
        f19 = f19 + f20;
        f8 = f8 + f13;
        f13 = f15 * f14;
        f14 = f19 + f17;
        f8 = f8 + f13;
        r5 = r4 >> numDefine2;
        heapClassInst.heapFloat[fp + numDefineNeg12] = f18;
        f8 = f8 + f16;
        heapClassInst.heapFloat[r5 + 1] = f14;
        heapClassInst.heapFloat[r5 + numDefine2] = f8;
        heapClassInst.heap32[r5 + numDefine3] = 0;
        f13 = heapClassInst.heapFloat[r1 + numDefine8];
        f19 = heapClassInst.heapFloat[r1 + numDefine9];
        f20 = heapClassInst.heapFloat[r1 + numDefine10];
        f1 = f1 * f13;
        f3 = f3 * f19;
        f4 = f4 * f13;
        f5 = f5 * f19;
        f1 = f1 + f3;
        f3 = f9 * f20;
        f1 = f1 + f3;
        f3 = f10 * f13;
        f9 = f11 * f19;
        f4 = f4 + f5;
        f5 = f12 * f20;
        r1 = sp + numDefineNeg64;
        f4 = f4 + f5;
        f1 = f1 + f7;
        f3 = f3 + f9;
        f5 = f15 * f20;
        f3 = f3 + f5;
        f4 = f4 + f17;
        r5 = r1 >> numDefine2;
        heapClassInst.heapFloat[fp + numDefineNeg16] = f1;
        f5 = f6 + f18;
        f3 = f3 + f16;
        heapClassInst.heapFloat[r5 + 1] = f4;
        f7 = f2 + f14;
        heapClassInst.heapFloat[r5 + numDefine2] = f3;
        f5 = f5 + f1;
        f9 = (float) numDefineFloat308;
        r6 = sp + numDefineNeg80;
        f10 = f0 + f8;
        f7 = f7 + f4;
        f8 = f8 - f0;
        f4 = f4 - f2;
        f11 = f18 - f6;
        f0 = f3 - f0;
        f2 = f14 - f2;
        f1 = f1 - f6;
        f5 = f5 * f9;
        heapClassInst.heap32[r5 + numDefine3] = 0;
        f3 = f10 + f3;
        f6 = f2 * f0;
        f10 = f8 * f4;
        f8 = f8 * f1;
        f0 = f11 * f0;
        r5 = r6 >> numDefine2;
        f7 = f7 * f9;
        heapClassInst.heapFloat[fp + numDefineNeg20] = f5;
        f5 = f6 - f10;
        f0 = f8 - f0;
        f4 = f11 * f4;
        f1 = f2 * f1;
        f2 = f3 * f9;
        heapClassInst.heapFloat[r5 + 1] = f7;
        f1 = f4 - f1;
        heapClassInst.heapFloat[r5 + numDefine2] = f2;
        f2 = f5 * f5;
        f3 = f0 * f0;
        heapClassInst.heap32[r5 + numDefine3] = 0;
        f2 = f2 + f3;
        f3 = f1 * f1;
        f2 = f2 + f3;
        heapClassInst.heapFloat[g0] = f2;
        r7 = sp + numDefineNeg96;
        sqrtf(i7);
        r8 = r7 >> numDefine2;
        heapClassInst.heap32[fp + numDefineNeg24] = numDefine53216;
        heapClassInst.heap32[r8 + 1] = numDefine53216;
        heapClassInst.heap32[r8 + numDefine2] = 0;
        heapClassInst.heap32[r8 + numDefine3] = 0;
        r8 = heapClassInst.heap32[r2 + numDefine2];
        r9 = r8 >> numDefine2;
        f3 = 1;
        r9 = heapClassInst.heap32[r9];
        f2 = (float) (f3 / commonVariable.fg0);
        r9 = r9 >> numDefine2;
        r9 = heapClassInst.heap32[r9 + numDefine2];
        f3 = f5 * f2;
        f4 = heapClassInst.heapFloat[fp + numDefineNeg20];
        f5 = heapClassInst.heapFloat[r5 + numDefine2];
        f6 = heapClassInst.heapFloat[r5 + 1];
        r5 = sp + numDefineNeg16;
        f0 = f0 * f2;
        f3 = f4 + f3;
        f1 = f1 * f2;
        r10 = r5 >> numDefine2;
        f0 = f6 + f0;
        heapClassInst.heapFloat[fp + numDefineNeg4] = f3;
        f1 = f5 + f1;
        heapClassInst.heapFloat[r10 + 1] = f0;
        heapClassInst.heapFloat[r10 + numDefine2] = f1;
        heapClassInst.heap32[r10 + numDefine3] = 0;
        heapClassInst.heap32[g0] = r8;
        heapClassInst.heap32[g0 + 1] = r6;
        heapClassInst.heap32[g0 + numDefine2] = r5;
        heapClassInst.heap32[g0 + numDefine3] = r7;
        functionTable.get(r9 >> numDefine2).accept(i7);
        r5 = heapClassInst.heap32[r2 + numDefine2];
        r6 = r5 >> numDefine2;
        r6 = heapClassInst.heap32[r6];
        r6 = r6 >> numDefine2;
        r6 = heapClassInst.heap32[r6 + numDefine2];
        r0 = (r0 + numDefine12) | 0;
        heapClassInst.heap32[g0] = r5;
        heapClassInst.heap32[g0 + 1] = r3;
        heapClassInst.heap32[g0 + numDefine2] = r4;
        heapClassInst.heap32[g0 + numDefine3] = r0;
        functionTable.get(r6 >> numDefine2).accept(i7);
        r5 = heapClassInst.heap32[r2 + numDefine2];
        r6 = r5 >> numDefine2;
        r6 = heapClassInst.heap32[r6];
        r6 = r6 >> numDefine2;
        r6 = heapClassInst.heap32[r6 + numDefine2];
        heapClassInst.heap32[g0] = r5;
        heapClassInst.heap32[g0 + 1] = r4;
        heapClassInst.heap32[g0 + numDefine2] = r1;
        heapClassInst.heap32[g0 + numDefine3] = r0;
        functionTable.get(r6 >> numDefine2).accept(i7);
        r2 = heapClassInst.heap32[r2 + numDefine2];
        r4 = r2 >> numDefine2;
        r4 = heapClassInst.heap32[r4];
        r4 = r4 >> numDefine2;
        r4 = heapClassInst.heap32[r4 + numDefine2];
        heapClassInst.heap32[g0] = r2;
        heapClassInst.heap32[g0 + 1] = r1;
        heapClassInst.heap32[g0 + numDefine2] = r3;
        heapClassInst.heap32[g0 + numDefine3] = r0;
        functionTable.get(r4 >> numDefine2).accept(i7);
        
    }

    public static void zn17DebugDrawcallback28internalProcessTriangleIndexEP9btVector3ii(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int label = 0;
        i7 = sp + numDefineNeg16;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = r0 >> numDefine2;
        r1 = heapClassInst.heap32[r1];
        r1 = r1 >> numDefine2;
        r1 = heapClassInst.heap32[r1 + numDefine2];
        r2 = heapClassInst.heap32[fp + 1];
        r3 = heapClassInst.heap32[fp + numDefine2];
        r4 = heapClassInst.heap32[fp + numDefine3];
        heapClassInst.heap32[g0] = r0;
        heapClassInst.heap32[g0 + 1] = r2;
        heapClassInst.heap32[g0 + numDefine2] = r3;
        heapClassInst.heap32[g0 + numDefine3] = r4;
        functionTable.get(r1 >> numDefine2).accept(i7);
        
    }

    public static void zthn4N17DebugDrawcallbackD1Ev(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int label = 0;
        i7 = sp + 0;
        int g0 = i7 >> numDefine2;
        r0 = ztv17DebugDrawcallback;
        r1 = heapClassInst.heap32[fp];
        r1 = r1 >> numDefine2;
        r2 = (r0 + numDefine8) | 0;
        r3 = ztv31btInternalTriangleIndexCallback;
        r0 = (r0 + numDefine32) | 0;
        heapClassInst.heap32[r1 + -1] = r2;
        r2 = ztv18btTriangleCallback;
        r3 = (r3 + numDefine8) | 0;
        heapClassInst.heap32[r1] = r0;
        r0 = (r2 + numDefine8) | 0;
        heapClassInst.heap32[r1] = r3;
        heapClassInst.heap32[r1 + -1] = r0;
        
    }

    public static void zthn4N17DebugDrawcallbackD0Ev(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int label = 0;
        i7 = sp + numDefineNeg8;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = ztv17DebugDrawcallback;
        r2 = r0 >> numDefine2;
        r3 = (r1 + numDefine8) | 0;
        r4 = ztv31btInternalTriangleIndexCallback;
        r1 = (r1 + numDefine32) | 0;
        heapClassInst.heap32[r2 + -1] = r3;
        r3 = ztv18btTriangleCallback;
        r4 = (r4 + numDefine8) | 0;
        heapClassInst.heap32[r2] = r1;
        r1 = (r3 + numDefine8) | 0;
        heapClassInst.heap32[r2] = r4;
        heapClassInst.heap32[r2 + -1] = r1;
        r0 = (r0 + numDefineNeg4) | 0;
        heapClassInst.heap32[g0] = r0;
        zdlPv(i7);
        
    }

    public static void zthn4N17DebugDrawcallback28internalProcessTriangleIndexEP9btVector3ii(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int label = 0;
        i7 = sp + numDefineNeg16;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = r0 >> numDefine2;
        r1 = heapClassInst.heap32[r1 + -1];
        r1 = r1 >> numDefine2;
        r1 = heapClassInst.heap32[r1 + numDefine2];
        r0 = (r0 + numDefineNeg4) | 0;
        r2 = heapClassInst.heap32[fp + 1];
        r3 = heapClassInst.heap32[fp + numDefine2];
        r4 = heapClassInst.heap32[fp + numDefine3];
        heapClassInst.heap32[g0] = r0;
        heapClassInst.heap32[g0 + 1] = r2;
        heapClassInst.heap32[g0 + numDefine2] = r3;
        heapClassInst.heap32[g0 + numDefine3] = r4;
        functionTable.get(r1 >> numDefine2).accept(i7);
        
    }

    public static void zn16btCollisionWorldD1Ev(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int label = 0;
        i7 = sp + numDefineNeg8;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        heapClassInst.heap32[g0] = r0;
        zn16btCollisionWorldD2Ev(i7);
        
    }

    public static void zn16btCollisionWorldD0Ev(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        int r6 = 0;
        int r7 = 0;
        int label = 0;
        i7 = sp + numDefineNeg16;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = ztv16btCollisionWorld;
        r2 = r0 >> numDefine2;
        r1 = (r1 + numDefine8) | 0;
        heapClassInst.heap32[r2] = r1;
        r1 = heapClassInst.heap32[r2 + numDefine4];
        r3 = heapClassInst.heap32[r2 + numDefine2];
        if (r3 > 0) {
            r3 = 0;
            repeat3:
            while (true) {
                r4 = r3 << numDefine2;
                r1 = (r1 + r4) | 0;
                r1 = r1 >> numDefine2;
                r1 = heapClassInst.heap32[r1];
                r1 = r1 >> numDefine2;
                r4 = heapClassInst.heap32[r1 + numDefine47];
                if (!(r4 == 0)) {
                    r5 = heapClassInst.heap32[r2 + numDefine20];
                    r6 = r5 >> numDefine2;
                    r6 = heapClassInst.heap32[r6];
                    r6 = r6 >> numDefine2;
                    r6 = heapClassInst.heap32[r6 + numDefine9];
                    heapClassInst.heap32[g0] = r5;
                    functionTable.get(r6 >> numDefine2).accept(i7);
                    r6 = commonVariable.rg0 >> numDefine2;
                    r6 = heapClassInst.heap32[r6];
                    r6 = r6 >> numDefine2;
                    r6 = heapClassInst.heap32[r6 + numDefine10];
                    r7 = heapClassInst.heap32[r2 + numDefine6];
                    heapClassInst.heap32[g0] = commonVariable.rg0;
                    heapClassInst.heap32[g0 + 1] = r4;
                    heapClassInst.heap32[g0 + numDefine2] = r7;
                    functionTable.get(r6 >> numDefine2).accept(i7);
                    r5 = heapClassInst.heap32[r2 + numDefine20];
                    r6 = r5 >> numDefine2;
                    r6 = heapClassInst.heap32[r6];
                    r6 = r6 >> numDefine2;
                    r6 = heapClassInst.heap32[r6 + numDefine3];
                    r7 = heapClassInst.heap32[r2 + numDefine6];
                    heapClassInst.heap32[g0] = r5;
                    heapClassInst.heap32[g0 + 1] = r4;
                    heapClassInst.heap32[g0 + numDefine2] = r7;
                    functionTable.get(r6 >> numDefine2).accept(i7);
                    heapClassInst.heap32[r1 + numDefine47] = 0;
                }
                r3 = (r3 + 1) | 0;
                r1 = heapClassInst.heap32[r2 + numDefine4];
                r4 = heapClassInst.heap32[r2 + numDefine2];
                if (r4 > r3) {
                    continue repeat3;
                } else {
                    break repeat3;
                }
            }
        }
        if (!(r1 == 0)) {
            r3 = heapClassInst.heapU8[r0 + numDefine20];
            if (!(r3 == 0)) {
                r3 = gNumAlignedFree;
                r3 = r3 >> numDefine2;
                r4 = heapClassInst.heap32[r3];
                r4 = (r4 + 1) | 0;
                r1 = r1 >> numDefine2;
                heapClassInst.heap32[r3] = r4;
                r1 = heapClassInst.heap32[r1 + -1];
                heapClassInst.heap32[g0] = r1;
                free(i7);
            }
            heapClassInst.heap32[r2 + numDefine4] = 0;
        }
        r1 = 1;
        heapClassInst.heap8[r0 + numDefine20] = (byte) r1;
        heapClassInst.heap32[r2 + numDefine4] = 0;
        heapClassInst.heap32[r2 + numDefine2] = 0;
        heapClassInst.heap32[r2 + numDefine3] = 0;
        heapClassInst.heap32[g0] = r0;
        zdlPv(i7);
        
    }

    public static void zn16btCollisionWorld11updateAabbsEv(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        int r6 = 0;
        int r7 = 0;
        int r8 = 0;
        int r9 = 0;
        float f0 = 0.0F;
        float f1 = 0.0F;
        float f2 = 0.0F;
        float f3 = 0.0F;
        float f4 = 0.0F;
        float f5 = 0.0F;
        float f6 = 0.0F;
        int label = 0;
        i7 = sp + numDefineNeg64;
        int g0 = i7 >> numDefine2;
        r0 = twoEStr1998;
        r1 = heapClassInst.heap32[fp];
        heapClassInst.heap32[g0] = r0;
        r0 = r1 >> numDefine2;
        zn15CProfileManager13StartProfileEPKc(i7);
        r2 = heapClassInst.heap32[r0 + numDefine2];
        if (!(r2 < 1)) {
            r2 = 0;
            repeat3:
            while (true) {
                r3 = heapClassInst.heap32[r0 + numDefine4];
                r4 = r2 << numDefine2;
                r3 = (r3 + r4) | 0;
                r3 = r3 >> numDefine2;
                r2 = (r2 + 1) | 0;
                r3 = heapClassInst.heap32[r3];
                r4 = heapClassInst.heapU8[r1 + numDefine88];
                if (r4 != 0) {
                    label = numDefine5;
                } else {
                    r4 = r3 >> numDefine2;
                    r4 = heapClassInst.heap32[r4 + numDefine54];
                    if (r4 == numDefine2) {
                        label = numDefine13;
                    } else {
                        if (r4 == numDefine5) {
                            label = numDefine13;
                        } else {
                            label = numDefine5;
                        }
                    }
                }
                repeat8:
                do {
                    if (label == numDefine5) {
                        r4 = r3 >> numDefine2;
                        r5 = heapClassInst.heap32[r4 + numDefine48];
                        r6 = r5 >> numDefine2;
                        r6 = heapClassInst.heap32[r6];
                        r6 = r6 >> numDefine2;
                        r6 = heapClassInst.heap32[r6 + numDefine2];
                        r7 = sp + numDefineNeg40;
                        r8 = sp + numDefineNeg24;
                        r9 = (r3 + numDefine4) | 0;
                        heapClassInst.heap32[g0] = r5;
                        heapClassInst.heap32[g0 + 1] = r9;
                        heapClassInst.heap32[g0 + numDefine2] = r8;
                        heapClassInst.heap32[g0 + numDefine3] = r7;
                        functionTable.get(r6 >> numDefine2).accept(i7);
                        f0 = (float) numDefineNegFloat064;
                        f1 = heapClassInst.heapFloat[fp + numDefineNeg6];
                        f1 = f1 + f0;
                        r5 = r8 >> numDefine2;
                        heapClassInst.heapFloat[fp + numDefineNeg6] = f1;
                        f2 = heapClassInst.heapFloat[r5 + 1];
                        f2 = f2 + f0;
                        heapClassInst.heapFloat[r5 + 1] = f2;
                        f3 = heapClassInst.heapFloat[r5 + numDefine2];
                        f0 = f3 + f0;
                        heapClassInst.heapFloat[r5 + numDefine2] = f0;
                        f3 = (float) numDefineFloat064;
                        f4 = heapClassInst.heapFloat[fp + numDefineNeg10];
                        f4 = f4 + f3;
                        r5 = r7 >> numDefine2;
                        heapClassInst.heapFloat[fp + numDefineNeg10] = f4;
                        f5 = heapClassInst.heapFloat[r5 + 1];
                        f5 = f5 + f3;
                        heapClassInst.heapFloat[r5 + 1] = f5;
                        f6 = heapClassInst.heapFloat[r5 + numDefine2];
                        f3 = f6 + f3;
                        heapClassInst.heapFloat[r5 + numDefine2] = f3;
                        r5 = heapClassInst.heap32[r0 + numDefine20];
                        r3 = heapClassInst.heapU8[r3 + numDefine204];
                        r3 = r3 & 1;
                        if (!(r3 != 0)) {
                            f1 = f4 - f1;
                            f2 = f5 - f2;
                            f0 = f3 - f0;
                            f1 = f1 * f1;
                            f2 = f2 * f2;
                            f1 = f1 + f2;
                            f0 = f0 * f0;
                            f0 = f1 + f0;
                            f1 = numDefine95904;
                            if (!(f0 < f1)) {
                                r5 = heapClassInst.heap32[r4 + numDefine54];
                                r5 = (r5 + numDefineNeg4) | 0;
                                if (!(uint(r5) < uint(numDefine2))) {
                                    heapClassInst.heap32[r4 + numDefine54] = numDefine5;
                                }
                                r4 = zzn16btCollisionWorld16updateSingleAabbEP17btCollisionObjectE8reportMe2EB;
                                r5 = heapClassInst.heapU8[r4];
                                if (r5 != 0) {
                                    break repeat8;
                                } else {
                                    r3 = heapClassInst.heap32[r0 + numDefine21];
                                    if (r3 == 0) {
                                        break repeat8;
                                    } else {
                                        r5 = 1;
                                        r6 = r3 >> numDefine2;
                                        heapClassInst.heap8[r4] = (byte) r5;
                                        r4 = heapClassInst.heap32[r6];
                                        r4 = r4 >> numDefine2;
                                        r4 = heapClassInst.heap32[r4 + numDefine9];
                                        r5 = twoEStr1594;
                                        heapClassInst.heap32[g0] = r3;
                                        heapClassInst.heap32[g0 + 1] = r5;
                                        functionTable.get(r4 >> numDefine2).accept(i7);
                                        r3 = heapClassInst.heap32[r0 + numDefine21];
                                        r4 = r3 >> numDefine2;
                                        r4 = heapClassInst.heap32[r4];
                                        r4 = r4 >> numDefine2;
                                        r4 = heapClassInst.heap32[r4 + numDefine9];
                                        r5 = twoEStr1695;
                                        heapClassInst.heap32[g0] = r3;
                                        heapClassInst.heap32[g0 + 1] = r5;
                                        functionTable.get(r4 >> numDefine2).accept(i7);
                                        r3 = heapClassInst.heap32[r0 + numDefine21];
                                        r4 = r3 >> numDefine2;
                                        r4 = heapClassInst.heap32[r4];
                                        r4 = r4 >> numDefine2;
                                        r4 = heapClassInst.heap32[r4 + numDefine9];
                                        r5 = twoEStr1796;
                                        heapClassInst.heap32[g0] = r3;
                                        heapClassInst.heap32[g0 + 1] = r5;
                                        functionTable.get(r4 >> numDefine2).accept(i7);
                                        r3 = heapClassInst.heap32[r0 + numDefine21];
                                        r4 = r3 >> numDefine2;
                                        r4 = heapClassInst.heap32[r4];
                                        r4 = r4 >> numDefine2;
                                        r4 = heapClassInst.heap32[r4 + numDefine9];
                                        r5 = twoEStr1897;
                                        heapClassInst.heap32[g0] = r3;
                                        heapClassInst.heap32[g0 + 1] = r5;
                                        functionTable.get(r4 >> numDefine2).accept(i7);
                                        break repeat8;
                                    }
                                }
                            }
                        }
                        r3 = r5 >> numDefine2;
                        r3 = heapClassInst.heap32[r3];
                        r3 = r3 >> numDefine2;
                        r3 = heapClassInst.heap32[r3 + numDefine4];
                        r6 = heapClassInst.heap32[r0 + numDefine6];
                        r4 = heapClassInst.heap32[r4 + numDefine47];
                        heapClassInst.heap32[g0] = r5;
                        heapClassInst.heap32[g0 + 1] = r4;
                        heapClassInst.heap32[g0 + numDefine2] = r8;
                        heapClassInst.heap32[g0 + numDefine3] = r7;
                        heapClassInst.heap32[g0 + numDefine4] = r6;
                        functionTable.get(r3 >> numDefine2).accept(i7);
                    }
                } while (false);
                r3 = heapClassInst.heap32[r0 + numDefine2];
                if (r3 > r2) {
                    continue repeat3;
                } else {
                    break repeat3;
                }
            }
        }
        r0 = zn15CProfileManager11CurrentNodeE;
        r0 = r0 >> numDefine2;
        r1 = heapClassInst.heap32[r0];
        r2 = r1 >> numDefine2;
        r3 = heapClassInst.heap32[r2 + numDefine4];
        r3 = (r3 + -1) | 0;
        heapClassInst.heap32[r2 + numDefine4] = r3;
        repeat21:
        do {
            if (!(r3 != 0)) {
                r3 = heapClassInst.heap32[r2 + 1];
                if (r3 != 0) {
                    r1 = sp + numDefineNeg8;
                    heapClassInst.heap32[g0] = r1;
                    heapClassInst.heap32[g0 + 1] = 0;
                    r3 = zl13gProfileClock2E0;
                    getTimeOfDay(i7);
                    r3 = r3 >> numDefine2;
                    r3 = heapClassInst.heap32[r3];
                    r3 = r3 >> numDefine2;
                    r1 = r1 >> numDefine2;
                    r4 = heapClassInst.heap32[fp + numDefineNeg2];
                    r5 = heapClassInst.heap32[r3];
                    r4 = (r4 - r5) | 0;
                    r1 = heapClassInst.heap32[r1 + 1];
                    r3 = heapClassInst.heap32[r3 + 1];
                    r1 = (r1 - r3) | 0;
                    r3 = (int) ((r4 * numDefineN6) | 0);
                    r1 = (r1 + r3) | 0;
                    r3 = heapClassInst.heap32[r2 + numDefine3];
                    r1 = (r1 - r3) | 0;
                    f0 = uint(r1);
                    f1 = numDefine1000;
                    f2 = heapClassInst.heapFloat[r2 + numDefine2];
                    f0 = f0 / f1;
                    f0 = f2 + f0;
                    heapClassInst.heapFloat[r2 + numDefine2] = f0;
                    r1 = heapClassInst.heap32[r2 + numDefine4];
                    if (r1 != 0) {
                        break repeat21;
                    } else {
                        r1 = heapClassInst.heap32[r0];
                    }
                }
                r1 = r1 >> numDefine2;
                r1 = heapClassInst.heap32[r1 + numDefine5];
                heapClassInst.heap32[r0] = r1;
            }
        } while (false);
        
    }

    public static void zn16btCollisionWorld14debugDrawWorldEv(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        int r6 = 0;
        int r7 = 0;
        int r8 = 0;
        int r9 = 0;
        int r10 = 0;
        int r11 = 0;
        int r12 = 0;
        int r13 = 0;
        int r14 = 0;
        int r15 = 0;
        float f0 = 0.0F;
        int label = 0;
        i7 = sp + numDefineNeg104;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = r0 >> numDefine2;
        r2 = heapClassInst.heap32[r1];
        r2 = r2 >> numDefine2;
        r2 = heapClassInst.heap32[r2 + numDefine4];
        heapClassInst.heap32[g0] = r0;
        functionTable.get(r2 >> numDefine2).accept(i7);
        r2 = commonVariable.rg0;
        repeat1:
        do {
            if (!(r2 == 0)) {
                r2 = heapClassInst.heap32[r1];
                r2 = r2 >> numDefine2;
                r2 = heapClassInst.heap32[r2 + numDefine4];
                heapClassInst.heap32[g0] = r0;
                functionTable.get(r2 >> numDefine2).accept(i7);
                r3 = commonVariable.rg0 >> numDefine2;
                r3 = heapClassInst.heap32[r3];
                r3 = r3 >> numDefine2;
                r3 = heapClassInst.heap32[r3 + numDefine12];
                heapClassInst.heap32[g0] = commonVariable.rg0;
                functionTable.get(r3 >> numDefine2).accept(i7);
                r2 = commonVariable.rg0 & numDefine8;
                if (!(r2 == 0)) {
                    r2 = heapClassInst.heap32[r1 + numDefine6];
                    r3 = r2 >> numDefine2;
                    r3 = heapClassInst.heap32[r3];
                    r3 = r3 >> numDefine2;
                    r3 = heapClassInst.heap32[r3 + numDefine9];
                    heapClassInst.heap32[g0] = r2;
                    functionTable.get(r3 >> numDefine2).accept(i7);
                    r2 = commonVariable.rg0;
                    r3 = sp + numDefineNeg16;
                    r4 = r3 >> numDefine2;
                    heapClassInst.heap32[fp + numDefineNeg4] = 0;
                    heapClassInst.heap32[r4 + 1] = 0;
                    r5 = 0;
                    heapClassInst.heap32[r4 + numDefine2] = 0;
                    heapClassInst.heap32[r4 + numDefine3] = 0;
                    repeat4:
                    while (true) {
                        if (r5 < r2) {
                            r4 = heapClassInst.heap32[r1 + numDefine6];
                            r6 = r4 >> numDefine2;
                            r6 = heapClassInst.heap32[r6];
                            r6 = r6 >> numDefine2;
                            r6 = heapClassInst.heap32[r6 + numDefine10];
                            heapClassInst.heap32[g0] = r4;
                            heapClassInst.heap32[g0 + 1] = r5;
                            functionTable.get(r6 >> numDefine2).accept(i7);
                            r4 = commonVariable.rg0;
                            r6 = r4 >> numDefine2;
                            r6 = heapClassInst.heap32[r6 + numDefine279];
                            r7 = numDefine36;
                            r8 = numDefine68;
                            r9 = 0;
                            repeat7:
                            while (true) {
                                if (r9 < r6) {
                                    r10 = r4 >> numDefine2;
                                    r10 = heapClassInst.heap32[r10 + numDefine279];
                                    if (r10 > r9) {
                                        r10 = (r9 * numDefine69) | 0;
                                        r11 = (r4 + r7) | 0;
                                        r12 = (r4 + r8) | 0;
                                        r13 = heapClassInst.heap32[r1];
                                        r13 = r13 >> numDefine2;
                                        r13 = heapClassInst.heap32[r13 + numDefine4];
                                        heapClassInst.heap32[g0] = r0;
                                        functionTable.get(r13 >> numDefine2).accept(i7);
                                        r14 = commonVariable.rg0 >> numDefine2;
                                        r15 = r10 << numDefine2;
                                        r10 = r10 << numDefine2;
                                        r14 = heapClassInst.heap32[r14];
                                        r15 = (r4 + r15) | 0;
                                        r10 = (r4 + r10) | 0;
                                        r14 = r14 >> numDefine2;
                                        r15 = r15 >> numDefine2;
                                        r10 = r10 >> numDefine2;
                                        r14 = heapClassInst.heap32[r14 + numDefine8];
                                        r15 = heapClassInst.heap32[r15 + numDefine37];
                                        f0 = heapClassInst.heapFloat[r10 + numDefine21];
                                        heapClassInst.heap32[g0] = commonVariable.rg0;
                                        heapClassInst.heap32[g0 + 1] = r11;
                                        heapClassInst.heap32[g0 + numDefine2] = r12;
                                        heapClassInst.heapFloat[g0 + numDefine3] = f0;
                                        heapClassInst.heap32[g0 + numDefine4] = r15;
                                        heapClassInst.heap32[g0 + numDefine5] = r3;
                                        r9 = (r9 + 1) | 0;
                                        r8 = (r8 + numDefine276) | 0;
                                        r7 = (r7 + numDefine276) | 0;
                                        functionTable.get(r14 >> numDefine2).accept(i7);
                                    } else {
                                        break repeat4;
                                    }
                                } else {
                                    break repeat7;
                                }
                            }
                            r5 = (r5 + 1) | 0;
                        } else {
                            break repeat1;
                        }
                    }
                    r0 = twoEStr382;
                    r1 = twoEStr483;
                    heapClassInst.heap32[g0] = r0;
                    heapClassInst.heap32[g0 + 1] = r1;
                    heapClassInst.heap32[g0 + numDefine2] = numDefine122;
                    assertNew(i7);
                }
            }
        } while (false);
        r2 = heapClassInst.heap32[r1];
        r2 = r2 >> numDefine2;
        r2 = heapClassInst.heap32[r2 + numDefine4];
        heapClassInst.heap32[g0] = r0;
        functionTable.get(r2 >> numDefine2).accept(i7);
        r2 = commonVariable.rg0;
        repeat14:
        do {
            if (!(r2 == 0)) {
                r2 = heapClassInst.heap32[r1];
                r2 = r2 >> numDefine2;
                r2 = heapClassInst.heap32[r2 + numDefine4];
                heapClassInst.heap32[g0] = r0;
                functionTable.get(r2 >> numDefine2).accept(i7);
                r3 = commonVariable.rg0 >> numDefine2;
                r3 = heapClassInst.heap32[r3];
                r3 = r3 >> numDefine2;
                r3 = heapClassInst.heap32[r3 + numDefine12];
                heapClassInst.heap32[g0] = commonVariable.rg0;
                functionTable.get(r3 >> numDefine2).accept(i7);
                r2 = commonVariable.rg0 & numDefine3;
                if (!(r2 == 0)) {
                    r2 = heapClassInst.heap32[r1 + numDefine2];
                    if (r2 > 0) {
                        r2 = 0;
                        repeat18:
                        while (true) {
                            r3 = heapClassInst.heap32[r1 + numDefine4];
                            r4 = r2 << numDefine2;
                            r3 = (r3 + r4) | 0;
                            r3 = r3 >> numDefine2;
                            r3 = heapClassInst.heap32[r3];
                            r4 = heapClassInst.heapU8[r3 + numDefine204];
                            r4 = r4 & numDefine32;
                            if (!(r4 != 0)) {
                                r4 = heapClassInst.heap32[r1];
                                r4 = r4 >> numDefine2;
                                r4 = heapClassInst.heap32[r4 + numDefine4];
                                heapClassInst.heap32[g0] = r0;
                                functionTable.get(r4 >> numDefine2).accept(i7);
                                r4 = commonVariable.rg0;
                                if (!(r4 == 0)) {
                                    r4 = heapClassInst.heap32[r1];
                                    r4 = r4 >> numDefine2;
                                    r4 = heapClassInst.heap32[r4 + numDefine4];
                                    heapClassInst.heap32[g0] = r0;
                                    functionTable.get(r4 >> numDefine2).accept(i7);
                                    r5 = commonVariable.rg0 >> numDefine2;
                                    r5 = heapClassInst.heap32[r5];
                                    r5 = r5 >> numDefine2;
                                    r5 = heapClassInst.heap32[r5 + numDefine12];
                                    heapClassInst.heap32[g0] = commonVariable.rg0;
                                    functionTable.get(r5 >> numDefine2).accept(i7);
                                    r4 = commonVariable.rg0 & 1;
                                    if (!(r4 == 0)) {
                                        r4 = sp + numDefineNeg32;
                                        r5 = r4 >> numDefine2;
                                        heapClassInst.heap32[fp + numDefineNeg8] = numDefine53216;
                                        heapClassInst.heap32[r5 + 1] = numDefine53216;
                                        heapClassInst.heap32[r5 + numDefine2] = numDefine53216;
                                        r6 = r3 >> numDefine2;
                                        heapClassInst.heap32[r5 + numDefine3] = 0;
                                        r7 = heapClassInst.heap32[r6 + numDefine54];
                                        repeat25:
                                        do {
                                            if (r7 > numDefine2) {
                                                if (r7 == numDefine3) {
                                                    heapClassInst.heap32[fp + numDefineNeg8] = 0;
                                                    heapClassInst.heap32[r5 + 1] = numDefine53216;
                                                    heapClassInst.heap32[r5 + numDefine2] = numDefine53216;
                                                    heapClassInst.heap32[r5 + numDefine3] = 0;
                                                    label = numDefine30;
                                                    break repeat25;
                                                } else {
                                                    if (r7 == numDefine4) {
                                                        heapClassInst.heap32[fp + numDefineNeg8] = numDefine53216;
                                                        heapClassInst.heap32[r5 + 1] = 0;
                                                        heapClassInst.heap32[r5 + numDefine2] = 0;
                                                        heapClassInst.heap32[r5 + numDefine3] = 0;
                                                        label = numDefine30;
                                                        break repeat25;
                                                    } else {
                                                        if (r7 == numDefine5) {
                                                            heapClassInst.heap32[fp + numDefineNeg8] = numDefine53216;
                                                            heapClassInst.heap32[r5 + 1] = numDefine53216;
                                                            heapClassInst.heap32[r5 + numDefine2] = 0;
                                                            heapClassInst.heap32[r5 + numDefine3] = 0;
                                                            label = numDefine30;
                                                            break repeat25;
                                                        } else {
                                                            label = numDefine29;
                                                            break repeat25;
                                                        }
                                                    }
                                                }
                                            } else {
                                                if (r7 == 1) {
                                                    heapClassInst.heap32[fp + numDefineNeg8] = numDefine53216;
                                                    heapClassInst.heap32[r5 + 1] = numDefine53216;
                                                    heapClassInst.heap32[r5 + numDefine2] = numDefine53216;
                                                    heapClassInst.heap32[r5 + numDefine3] = 0;
                                                    label = numDefine30;
                                                } else {
                                                    if (r7 == numDefine2) {
                                                        heapClassInst.heap32[fp + numDefineNeg8] = 0;
                                                        heapClassInst.heap32[r5 + 1] = numDefine53216;
                                                        heapClassInst.heap32[r5 + numDefine2] = 0;
                                                        heapClassInst.heap32[r5 + numDefine3] = 0;
                                                        label = numDefine30;
                                                    } else {
                                                        label = numDefine29;
                                                    }
                                                }
                                            }
                                        } while (false);
                                        if (label == numDefine29) {
                                            heapClassInst.heap32[fp + numDefineNeg8] = numDefine53216;
                                            heapClassInst.heap32[r5 + 1] = 0;
                                            heapClassInst.heap32[r5 + numDefine2] = 0;
                                            heapClassInst.heap32[r5 + numDefine3] = 0;
                                        }
                                        r5 = heapClassInst.heap32[r1];
                                        r5 = r5 >> numDefine2;
                                        r5 = heapClassInst.heap32[r5 + numDefine6];
                                        r6 = heapClassInst.heap32[r6 + numDefine48];
                                        r7 = (r3 + numDefine4) | 0;
                                        heapClassInst.heap32[g0] = r0;
                                        heapClassInst.heap32[g0 + 1] = r7;
                                        heapClassInst.heap32[g0 + numDefine2] = r6;
                                        heapClassInst.heap32[g0 + numDefine3] = r4;
                                        functionTable.get(r5 >> numDefine2).accept(i7);
                                    }
                                }
                                r4 = heapClassInst.heap32[r1 + numDefine21];
                                if (!(r4 == 0)) {
                                    r5 = r4 >> numDefine2;
                                    r5 = heapClassInst.heap32[r5];
                                    r5 = r5 >> numDefine2;
                                    r5 = heapClassInst.heap32[r5 + numDefine12];
                                    heapClassInst.heap32[g0] = r4;
                                    functionTable.get(r5 >> numDefine2).accept(i7);
                                    r4 = commonVariable.rg0 & numDefine2;
                                    if (!(r4 == 0)) {
                                        r4 = sp + numDefineNeg80;
                                        r5 = r4 >> numDefine2;
                                        heapClassInst.heap32[fp + numDefineNeg20] = numDefine53216;
                                        heapClassInst.heap32[r5 + 1] = 0;
                                        heapClassInst.heap32[r5 + numDefine2] = 0;
                                        r6 = r3 >> numDefine2;
                                        heapClassInst.heap32[r5 + numDefine3] = 0;
                                        r5 = heapClassInst.heap32[r6 + numDefine48];
                                        r6 = r5 >> numDefine2;
                                        r6 = heapClassInst.heap32[r6];
                                        r6 = r6 >> numDefine2;
                                        r6 = heapClassInst.heap32[r6 + numDefine2];
                                        r3 = (r3 + numDefine4) | 0;
                                        r7 = sp + numDefineNeg48;
                                        r8 = sp + numDefineNeg64;
                                        heapClassInst.heap32[g0] = r5;
                                        heapClassInst.heap32[g0 + 1] = r3;
                                        heapClassInst.heap32[g0 + numDefine2] = r7;
                                        heapClassInst.heap32[g0 + numDefine3] = r8;
                                        functionTable.get(r6 >> numDefine2).accept(i7);
                                        r3 = heapClassInst.heap32[r1 + numDefine21];
                                        r5 = r3 >> numDefine2;
                                        r5 = heapClassInst.heap32[r5];
                                        r5 = r5 >> numDefine2;
                                        r5 = heapClassInst.heap32[r5 + numDefine13];
                                        heapClassInst.heap32[g0] = r3;
                                        heapClassInst.heap32[g0 + 1] = r7;
                                        heapClassInst.heap32[g0 + numDefine2] = r8;
                                        heapClassInst.heap32[g0 + numDefine3] = r4;
                                        functionTable.get(r5 >> numDefine2).accept(i7);
                                    }
                                }
                            }
                            r2 = (r2 + 1) | 0;
                            r3 = heapClassInst.heap32[r1 + numDefine2];
                            if (r3 > r2) {
                                continue repeat18;
                            } else {
                                break repeat14;
                            }
                        }
                    }
                }
            }
        } while (false);
        
    }

    public static void zn16btCollisionWorld15debugDrawObjectERK11btTransformPK16btCollisionShapeRK9btVector3(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        int r6 = 0;
        int r7 = 0;
        int r8 = 0;
        int r9 = 0;
        int r10 = 0;
        int r11 = 0;
        int r12 = 0;
        int r13 = 0;
        int r14 = 0;
        int r15 = 0;
        float f0 = 0.0F;
        float f1 = 0.0F;
        float f2 = 0.0F;
        float f3 = 0.0F;
        float f4 = 0.0F;
        float f5 = 0.0F;
        float f6 = 0.0F;
        float f7 = 0.0F;
        float f8 = 0.0F;
        float f9 = 0.0F;
        float f10 = 0.0F;
        float f11 = 0.0F;
        float f12 = 0.0F;
        float f13 = 0.0F;
        float f14 = 0.0F;
        float f15 = 0.0F;
        float f16 = 0.0F;
        float f17 = 0.0F;
        float f18 = 0.0F;
        float f19 = 0.0F;
        float f20 = 0.0F;
        float f21 = 0.0F;
        float f22 = 0.0F;
        float f23 = 0.0F;
        float f24 = 0.0F;
        float f25 = 0.0F;
        float f26 = 0.0F;
        float f27 = 0.0F;
        float f28 = 0.0F;
        float f29 = 0.0F;
        int label = 0;
        i7 = sp + numDefineNeg1376;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = r0 >> numDefine2;
        r2 = heapClassInst.heap32[r1];
        r2 = r2 >> numDefine2;
        r2 = heapClassInst.heap32[r2 + numDefine4];
        heapClassInst.heap32[g0] = r0;
        functionTable.get(r2 >> numDefine2).accept(i7);
        r3 = commonVariable.rg0 >> numDefine2;
        r3 = heapClassInst.heap32[r3];
        r3 = r3 >> numDefine2;
        r3 = heapClassInst.heap32[r3 + numDefine14];
        r4 = heapClassInst.heap32[fp + 1];
        heapClassInst.heap32[g0] = commonVariable.rg0;
        heapClassInst.heap32[g0 + 1] = r4;
        heapClassInst.heap32[g0 + numDefine2] = numDefine53216;
        r2 = heapClassInst.heap32[fp + numDefine2];
        r5 = r2 >> numDefine2;
        functionTable.get(r3 >> numDefine2).accept(i7);
        r3 = heapClassInst.heap32[r5 + 1];
        r6 = heapClassInst.heap32[fp + numDefine3];
        repeat1:
        do {
            if (r3 > numDefine10) {
                if (r3 > numDefine27) {
                    if (r3 == numDefine28) {
                        f0 = heapClassInst.heapFloat[r5 + numDefine14];
                        f1 = heapClassInst.heapFloat[r5 + numDefine13];
                        f2 = heapClassInst.heapFloat[r5 + numDefine16];
                        f3 = heapClassInst.heapFloat[r5 + numDefine12];
                        f4 = f0 * f2;
                        f5 = f1 * f2;
                        f2 = f3 * f2;
                        f6 = 0;
                        if (f0 < f6) {
                            f7 = -f0;
                        } else {
                            f7 = f0;
                        }
                        f8 = (float) numDefineFloat742;
                        if (f7 <= f8) {
                            f0 = f3 * f3;
                            f1 = f1 * f1;
                            f0 = f0 + f1;
                            heapClassInst.heapFloat[g0] = f0;
                            sqrtf(i7);
                            f3 = 1;
                            f7 = heapClassInst.heapFloat[r5 + numDefine13];
                            f9 = heapClassInst.heapFloat[r5 + numDefine14];
                            f10 = (float) (f3 / commonVariable.fg0);
                            f1 = heapClassInst.heapFloat[r5 + numDefine12];
                            f3 = -f7;
                            f8 = f1 * f10;
                            f1 = -f9;
                            f11 = f10 * f3;
                            f12 = numDefine100;
                            f1 = f8 * f1;
                            f3 = f9 * f11;
                            f7 = f0 * f10;
                            f0 = f11 * f12;
                        } else {
                            f1 = f1 * f1;
                            f3 = f0 * f0;
                            f1 = f1 + f3;
                            heapClassInst.heapFloat[g0] = f1;
                            sqrtf(i7);
                            f6 = heapClassInst.heapFloat[r5 + numDefine14];
                            f0 = 1;
                            f7 = heapClassInst.heapFloat[r5 + numDefine12];
                            f3 = (float) (f0 / commonVariable.fg0);
                            f6 = -f6;
                            f0 = heapClassInst.heapFloat[r5 + numDefine13];
                            f8 = f3 * f6;
                            f6 = -f7;
                            f0 = f0 * f3;
                            f9 = numDefine100;
                            f1 = f1 * f3;
                            f3 = f0 * f6;
                            f7 = f7 * f8;
                            f6 = f0 * f9;
                            f0 = 0;
                        }
                        r2 = heapClassInst.heap32[r1];
                        r2 = r2 >> numDefine2;
                        r2 = heapClassInst.heap32[r2 + numDefine4];
                        heapClassInst.heap32[g0] = r0;
                        f9 = numDefine100;
                        functionTable.get(r2 >> numDefine2).accept(i7);
                        r3 = r4 >> numDefine2;
                        f8 = f8 * f9;
                        r4 = commonVariable.rg0 >> numDefine2;
                        f10 = f2 - f0;
                        f11 = heapClassInst.heapFloat[r3];
                        f12 = f5 - f8;
                        f13 = heapClassInst.heapFloat[r3 + 1];
                        r4 = heapClassInst.heap32[r4];
                        f14 = heapClassInst.heapFloat[r3 + numDefine4];
                        f15 = heapClassInst.heapFloat[r3 + numDefine5];
                        f16 = f11 * f10;
                        f17 = f13 * f12;
                        f18 = f4 - f6;
                        f19 = heapClassInst.heapFloat[r3 + numDefine2];
                        r4 = r4 >> numDefine2;
                        f20 = heapClassInst.heapFloat[r3 + numDefine8];
                        f21 = heapClassInst.heapFloat[r3 + numDefine9];
                        f22 = heapClassInst.heapFloat[r3 + numDefine6];
                        f23 = f14 * f10;
                        f24 = f15 * f12;
                        f16 = f16 + f17;
                        f17 = f19 * f18;
                        f25 = heapClassInst.heapFloat[r3 + numDefine10];
                        r4 = heapClassInst.heap32[r4 + numDefine2];
                        f10 = f20 * f10;
                        f12 = f21 * f12;
                        f23 = f23 + f24;
                        f24 = f22 * f18;
                        f16 = f16 + f17;
                        f17 = heapClassInst.heapFloat[r3 + numDefine12];
                        f26 = heapClassInst.heapFloat[r3 + numDefine14];
                        f27 = heapClassInst.heapFloat[r3 + numDefine13];
                        f0 = f2 + f0;
                        f8 = f5 + f8;
                        r5 = sp + numDefineNeg64;
                        f23 = f23 + f24;
                        f10 = f10 + f12;
                        f12 = f25 * f18;
                        f16 = f16 + f17;
                        f6 = f4 + f6;
                        f10 = f10 + f12;
                        f11 = f11 * f0;
                        f12 = f13 * f8;
                        r7 = r5 >> numDefine2;
                        f13 = f23 + f27;
                        heapClassInst.heapFloat[fp + numDefineNeg16] = f16;
                        f14 = f14 * f0;
                        f15 = f15 * f8;
                        f11 = f11 + f12;
                        f12 = f19 * f6;
                        f10 = f10 + f26;
                        heapClassInst.heapFloat[r7 + 1] = f13;
                        f11 = f11 + f12;
                        heapClassInst.heapFloat[r7 + numDefine2] = f10;
                        f0 = f20 * f0;
                        f8 = f21 * f8;
                        f10 = f14 + f15;
                        f12 = f22 * f6;
                        r8 = sp + numDefineNeg48;
                        f10 = f10 + f12;
                        f0 = f0 + f8;
                        f6 = f25 * f6;
                        f8 = f11 + f17;
                        heapClassInst.heap32[r7 + numDefine3] = 0;
                        f0 = f0 + f6;
                        r7 = r8 >> numDefine2;
                        f6 = f10 + f27;
                        heapClassInst.heapFloat[fp + numDefineNeg12] = f8;
                        f0 = f0 + f26;
                        heapClassInst.heapFloat[r7 + 1] = f6;
                        heapClassInst.heapFloat[r7 + numDefine2] = f0;
                        heapClassInst.heap32[r7 + numDefine3] = 0;
                        heapClassInst.heap32[g0] = commonVariable.rg0;
                        heapClassInst.heap32[g0 + 1] = r8;
                        heapClassInst.heap32[g0 + numDefine2] = r5;
                        heapClassInst.heap32[g0 + numDefine3] = r6;
                        functionTable.get(r4 >> numDefine2).accept(i7);
                        r1 = heapClassInst.heap32[r1];
                        r1 = r1 >> numDefine2;
                        r1 = heapClassInst.heap32[r1 + numDefine4];
                        heapClassInst.heap32[g0] = r0;
                        functionTable.get(r1 >> numDefine2).accept(i7);
                        f0 = f1 * f9;
                        f1 = f3 * f9;
                        f3 = f7 * f9;
                        r1 = commonVariable.rg0 >> numDefine2;
                        f6 = f2 - f0;
                        f7 = heapClassInst.heapFloat[r3];
                        f8 = f5 - f1;
                        f9 = heapClassInst.heapFloat[r3 + 1];
                        r1 = heapClassInst.heap32[r1];
                        f10 = heapClassInst.heapFloat[r3 + numDefine4];
                        f11 = heapClassInst.heapFloat[r3 + numDefine5];
                        f12 = f7 * f6;
                        f13 = f9 * f8;
                        f14 = f4 - f3;
                        f15 = heapClassInst.heapFloat[r3 + numDefine2];
                        r1 = r1 >> numDefine2;
                        f16 = heapClassInst.heapFloat[r3 + numDefine8];
                        f17 = heapClassInst.heapFloat[r3 + numDefine9];
                        f18 = heapClassInst.heapFloat[r3 + numDefine6];
                        f19 = f10 * f6;
                        f20 = f11 * f8;
                        f12 = f12 + f13;
                        f13 = f15 * f14;
                        f21 = heapClassInst.heapFloat[r3 + numDefine10];
                        r1 = heapClassInst.heap32[r1 + numDefine2];
                        f6 = f16 * f6;
                        f8 = f17 * f8;
                        f19 = f19 + f20;
                        f20 = f18 * f14;
                        f12 = f12 + f13;
                        f13 = heapClassInst.heapFloat[r3 + numDefine12];
                        f22 = heapClassInst.heapFloat[r3 + numDefine14];
                        f23 = heapClassInst.heapFloat[r3 + numDefine13];
                        f0 = f2 + f0;
                        f1 = f5 + f1;
                        r2 = sp + numDefineNeg32;
                        f2 = f19 + f20;
                        f5 = f6 + f8;
                        f6 = f21 * f14;
                        f8 = f12 + f13;
                        f3 = f4 + f3;
                        f4 = f5 + f6;
                        f5 = f7 * f0;
                        f6 = f9 * f1;
                        r3 = r2 >> numDefine2;
                        f2 = f2 + f23;
                        heapClassInst.heapFloat[fp + numDefineNeg8] = f8;
                        f7 = f10 * f0;
                        f8 = f11 * f1;
                        f5 = f5 + f6;
                        f6 = f15 * f3;
                        f4 = f4 + f22;
                        heapClassInst.heapFloat[r3 + 1] = f2;
                        f2 = f5 + f6;
                        heapClassInst.heapFloat[r3 + numDefine2] = f4;
                        f0 = f16 * f0;
                        f1 = f17 * f1;
                        f4 = f7 + f8;
                        f5 = f18 * f3;
                        r4 = sp + numDefineNeg16;
                        f4 = f4 + f5;
                        f0 = f0 + f1;
                        f1 = f21 * f3;
                        f2 = f2 + f13;
                        heapClassInst.heap32[r3 + numDefine3] = 0;
                        f0 = f0 + f1;
                        r3 = r4 >> numDefine2;
                        f1 = f4 + f23;
                        heapClassInst.heapFloat[fp + numDefineNeg4] = f2;
                        f0 = f0 + f22;
                        heapClassInst.heapFloat[r3 + 1] = f1;
                        heapClassInst.heapFloat[r3 + numDefine2] = f0;
                        heapClassInst.heap32[r3 + numDefine3] = 0;
                        heapClassInst.heap32[g0] = commonVariable.rg0;
                        heapClassInst.heap32[g0 + 1] = r4;
                        label = numDefine30;
                        break repeat1;
                    } else {
                        if (r3 != numDefine31) {
                            label = numDefine32;
                            break repeat1;
                        } else {
                            r2 = heapClassInst.heap32[r5 + numDefine4];
                            r3 = (r2 + -1) | 0;
                            if (r3 < 0) {
                                label = numDefine40;
                                break repeat1;
                            } else {
                                r3 = 1;
                                r2 = (r3 - r2) | 0;
                                repeat18:
                                while (true) {
                                    r3 = r2;
                                    r2 = (r3 * numDefineNeg20) | 0;
                                    r7 = heapClassInst.heap32[r5 + numDefine6];
                                    r2 = r2 << numDefine2;
                                    r2 = (r7 + r2) | 0;
                                    r2 = r2 >> numDefine2;
                                    r7 = r4 >> numDefine2;
                                    r8 = heapClassInst.heap32[r1];
                                    f0 = heapClassInst.heapFloat[r2];
                                    f1 = heapClassInst.heapFloat[r7];
                                    f2 = heapClassInst.heapFloat[r2 + numDefine4];
                                    f3 = heapClassInst.heapFloat[r7 + 1];
                                    r8 = r8 >> numDefine2;
                                    f4 = heapClassInst.heapFloat[r2 + 1];
                                    f5 = heapClassInst.heapFloat[r2 + numDefine5];
                                    f6 = f0 * f1;
                                    f7 = f2 * f3;
                                    f8 = heapClassInst.heapFloat[r2 + numDefine8];
                                    f9 = heapClassInst.heapFloat[r7 + numDefine2];
                                    f10 = heapClassInst.heapFloat[r7 + numDefine8];
                                    f11 = heapClassInst.heapFloat[r2 + numDefine2];
                                    f12 = heapClassInst.heapFloat[r7 + numDefine4];
                                    f13 = heapClassInst.heapFloat[r2 + numDefine12];
                                    f14 = heapClassInst.heapFloat[r7 + numDefine9];
                                    f15 = heapClassInst.heapFloat[r2 + numDefine6];
                                    f16 = heapClassInst.heapFloat[r7 + numDefine5];
                                    f17 = heapClassInst.heapFloat[r2 + numDefine13];
                                    f18 = heapClassInst.heapFloat[r2 + numDefine9];
                                    f19 = heapClassInst.heapFloat[r7 + numDefine10];
                                    f20 = heapClassInst.heapFloat[r2 + numDefine10];
                                    f21 = heapClassInst.heapFloat[r7 + numDefine6];
                                    f22 = heapClassInst.heapFloat[r2 + numDefine14];
                                    r8 = heapClassInst.heap32[r8 + numDefine6];
                                    f23 = f4 * f1;
                                    f24 = f5 * f3;
                                    f6 = f6 + f7;
                                    f7 = f8 * f9;
                                    r2 = heapClassInst.heap32[r2 + numDefine16];
                                    f25 = heapClassInst.heapFloat[r7 + numDefine14];
                                    f26 = heapClassInst.heapFloat[r7 + numDefine13];
                                    f27 = heapClassInst.heapFloat[r7 + numDefine12];
                                    r7 = sp + numDefineNeg688;
                                    f28 = f11 * f1;
                                    f29 = f15 * f3;
                                    f23 = f23 + f24;
                                    f24 = f18 * f9;
                                    f6 = f6 + f7;
                                    r9 = r7 >> numDefine2;
                                    f7 = f28 + f29;
                                    f28 = f20 * f9;
                                    f23 = f23 + f24;
                                    heapClassInst.heapFloat[fp + numDefineNeg172] = f6;
                                    f6 = f0 * f12;
                                    f24 = f2 * f16;
                                    f7 = f7 + f28;
                                    heapClassInst.heapFloat[r9 + 1] = f23;
                                    heapClassInst.heapFloat[r9 + numDefine2] = f7;
                                    f7 = f4 * f12;
                                    f23 = f5 * f16;
                                    f6 = f6 + f24;
                                    f24 = f8 * f21;
                                    f28 = f11 * f12;
                                    f29 = f15 * f16;
                                    f7 = f7 + f23;
                                    f23 = f18 * f21;
                                    f6 = f6 + f24;
                                    heapClassInst.heap32[r9 + numDefine3] = 0;
                                    f24 = f28 + f29;
                                    f28 = f20 * f21;
                                    f7 = f7 + f23;
                                    heapClassInst.heapFloat[r9 + numDefine4] = f6;
                                    f0 = f0 * f10;
                                    f2 = f2 * f14;
                                    f6 = f24 + f28;
                                    heapClassInst.heapFloat[r9 + numDefine5] = f7;
                                    heapClassInst.heapFloat[r9 + numDefine6] = f6;
                                    f4 = f4 * f10;
                                    f5 = f5 * f14;
                                    f0 = f0 + f2;
                                    f2 = f8 * f19;
                                    f6 = f11 * f10;
                                    f7 = f15 * f14;
                                    f4 = f4 + f5;
                                    f5 = f18 * f19;
                                    f0 = f0 + f2;
                                    heapClassInst.heap32[r9 + numDefine7] = 0;
                                    f1 = f1 * f13;
                                    f2 = f3 * f17;
                                    f3 = f6 + f7;
                                    f6 = f20 * f19;
                                    f4 = f4 + f5;
                                    heapClassInst.heapFloat[r9 + numDefine8] = f0;
                                    f0 = f12 * f13;
                                    f5 = f16 * f17;
                                    f1 = f1 + f2;
                                    f2 = f9 * f22;
                                    f3 = f3 + f6;
                                    heapClassInst.heapFloat[r9 + numDefine9] = f4;
                                    f1 = f1 + f2;
                                    heapClassInst.heapFloat[r9 + numDefine10] = f3;
                                    f2 = f10 * f13;
                                    f3 = f14 * f17;
                                    f0 = f0 + f5;
                                    f4 = f21 * f22;
                                    f0 = f0 + f4;
                                    f2 = f2 + f3;
                                    f3 = f19 * f22;
                                    f1 = f1 + f27;
                                    heapClassInst.heap32[r9 + numDefine11] = 0;
                                    f2 = f2 + f3;
                                    f0 = f0 + f26;
                                    heapClassInst.heapFloat[r9 + numDefine12] = f1;
                                    f1 = f2 + f25;
                                    heapClassInst.heapFloat[r9 + numDefine13] = f0;
                                    heapClassInst.heapFloat[r9 + numDefine14] = f1;
                                    heapClassInst.heap32[r9 + numDefine15] = 0;
                                    heapClassInst.heap32[g0] = r0;
                                    heapClassInst.heap32[g0 + 1] = r7;
                                    heapClassInst.heap32[g0 + numDefine2] = r2;
                                    heapClassInst.heap32[g0 + numDefine3] = r6;
                                    r2 = (r3 + 1) | 0;
                                    functionTable.get(r8 >> numDefine2).accept(i7);
                                    if (r3 == 0) {
                                        label = numDefine40;
                                        break repeat1;
                                    } else {
                                        continue repeat18;
                                    }
                                }
                            }
                        }
                    }
                } else {
                    if (r3 == numDefine11) {
                        r2 = r4 >> numDefine2;
                        r3 = heapClassInst.heap32[r5 + numDefine17];
                        f0 = heapClassInst.heapFloat[r5 + numDefine14];
                        f1 = heapClassInst.heapFloat[r5 + numDefine15];
                        f2 = heapClassInst.heapFloat[r2 + numDefine12];
                        f3 = heapClassInst.heapFloat[r2 + numDefine13];
                        f4 = heapClassInst.heapFloat[r2 + numDefine14];
                        r4 = sp + numDefineNeg880;
                        r5 = r4 >> numDefine2;
                        heapClassInst.heap32[fp + numDefineNeg220] = 0;
                        heapClassInst.heap32[r5 + 1] = 0;
                        r7 = r3 << numDefine2;
                        r4 = (r4 + r7) | 0;
                        f5 = (float) numDefineFloat05;
                        heapClassInst.heap32[r5 + numDefine2] = 0;
                        r4 = r4 >> numDefine2;
                        f1 = f1 * f5;
                        heapClassInst.heap32[r5 + numDefine3] = 0;
                        r8 = sp + numDefineNeg896;
                        heapClassInst.heapFloat[r4] = f1;
                        r4 = (r3 + 1) | 0;
                        r4 = r4 % numDefine3 | 0;
                        r9 = r8 >> numDefine2;
                        heapClassInst.heap32[fp + numDefineNeg224] = 0;
                        heapClassInst.heap32[r9 + 1] = 0;
                        r4 = r4 << numDefine2;
                        r8 = (r8 + r4) | 0;
                        heapClassInst.heap32[r9 + numDefine2] = 0;
                        r8 = r8 >> numDefine2;
                        heapClassInst.heap32[r9 + numDefine3] = 0;
                        r3 = (r3 + numDefine2) | 0;
                        r10 = sp + numDefineNeg912;
                        heapClassInst.heapFloat[r8] = f0;
                        r3 = r3 % numDefine3 | 0;
                        r8 = r10 >> numDefine2;
                        heapClassInst.heap32[fp + numDefineNeg228] = 0;
                        r3 = r3 << numDefine2;
                        heapClassInst.heap32[r8 + 1] = 0;
                        r3 = (r10 + r3) | 0;
                        heapClassInst.heap32[r8 + numDefine2] = 0;
                        r3 = r3 >> numDefine2;
                        heapClassInst.heap32[r8 + numDefine3] = 0;
                        heapClassInst.heapFloat[r3] = f0;
                        r3 = heapClassInst.heap32[r1];
                        r3 = r3 >> numDefine2;
                        r3 = heapClassInst.heap32[r3 + numDefine4];
                        heapClassInst.heap32[g0] = r0;
                        functionTable.get(r3 >> numDefine2).accept(i7);
                        f1 = heapClassInst.heapFloat[r5 + 1];
                        f5 = heapClassInst.heapFloat[fp + numDefineNeg220];
                        f6 = heapClassInst.heapFloat[r9 + 1];
                        f7 = heapClassInst.heapFloat[fp + numDefineNeg224];
                        r10 = commonVariable.rg0 >> numDefine2;
                        f8 = heapClassInst.heapFloat[r5 + numDefine2];
                        f9 = heapClassInst.heapFloat[r9 + numDefine2];
                        f10 = heapClassInst.heapFloat[r2];
                        f11 = f7 - f5;
                        f12 = heapClassInst.heapFloat[r2 + 1];
                        f13 = f6 - f1;
                        f14 = heapClassInst.heapFloat[r2 + numDefine4];
                        f15 = heapClassInst.heapFloat[r2 + numDefine5];
                        r5 = heapClassInst.heap32[r10];
                        f16 = heapClassInst.heapFloat[r2 + numDefine2];
                        f17 = f9 - f8;
                        f18 = f10 * f11;
                        f19 = f12 * f13;
                        f20 = heapClassInst.heapFloat[r2 + numDefine8];
                        f21 = heapClassInst.heapFloat[r2 + numDefine9];
                        f22 = heapClassInst.heapFloat[r2 + numDefine6];
                        r5 = r5 >> numDefine2;
                        f23 = f14 * f11;
                        f24 = f15 * f13;
                        f18 = f18 + f19;
                        f19 = f16 * f17;
                        f25 = heapClassInst.heapFloat[r2 + numDefine10];
                        r5 = heapClassInst.heap32[r5 + numDefine2];
                        f18 = f18 + f19;
                        f11 = f20 * f11;
                        f13 = f21 * f13;
                        f19 = f23 + f24;
                        f23 = f22 * f17;
                        r9 = sp + numDefineNeg416;
                        f19 = f19 + f23;
                        f11 = f11 + f13;
                        f13 = f25 * f17;
                        f17 = f2 + f18;
                        f11 = f11 + f13;
                        f10 = f10 * f5;
                        f12 = f12 * f1;
                        r10 = r9 >> numDefine2;
                        f13 = f3 + f19;
                        heapClassInst.heapFloat[fp + numDefineNeg104] = f17;
                        f14 = f14 * f5;
                        f15 = f15 * f1;
                        f10 = f10 + f12;
                        f12 = f16 * f8;
                        f11 = f4 + f11;
                        heapClassInst.heapFloat[r10 + 1] = f13;
                        f10 = f10 + f12;
                        heapClassInst.heapFloat[r10 + numDefine2] = f11;
                        f11 = f20 * f5;
                        f12 = f21 * f1;
                        f13 = f14 + f15;
                        f14 = f22 * f8;
                        r11 = sp + numDefineNeg400;
                        f13 = f13 + f14;
                        f11 = f11 + f12;
                        f12 = f25 * f8;
                        f10 = f2 + f10;
                        heapClassInst.heap32[r10 + numDefine3] = 0;
                        f11 = f11 + f12;
                        r10 = r11 >> numDefine2;
                        f12 = f3 + f13;
                        heapClassInst.heapFloat[fp + numDefineNeg100] = f10;
                        f10 = f4 + f11;
                        heapClassInst.heapFloat[r10 + 1] = f12;
                        heapClassInst.heapFloat[r10 + numDefine2] = f10;
                        heapClassInst.heap32[r10 + numDefine3] = 0;
                        heapClassInst.heap32[g0] = commonVariable.rg0;
                        heapClassInst.heap32[g0 + 1] = r11;
                        heapClassInst.heap32[g0 + numDefine2] = r9;
                        heapClassInst.heap32[g0 + numDefine3] = r6;
                        functionTable.get(r5 >> numDefine2).accept(i7);
                        r3 = heapClassInst.heap32[r1];
                        r3 = r3 >> numDefine2;
                        r3 = heapClassInst.heap32[r3 + numDefine4];
                        heapClassInst.heap32[g0] = r0;
                        functionTable.get(r3 >> numDefine2).accept(i7);
                        f10 = -f5;
                        f11 = -f1;
                        f12 = -f8;
                        r5 = commonVariable.rg0 >> numDefine2;
                        f13 = heapClassInst.heapFloat[r2];
                        f7 = f10 - f7;
                        f14 = heapClassInst.heapFloat[r2 + 1];
                        f6 = f11 - f6;
                        f15 = heapClassInst.heapFloat[r2 + numDefine4];
                        f16 = heapClassInst.heapFloat[r2 + numDefine5];
                        r5 = heapClassInst.heap32[r5];
                        f17 = heapClassInst.heapFloat[r2 + numDefine2];
                        f9 = f12 - f9;
                        f18 = f13 * f7;
                        f19 = f14 * f6;
                        f20 = heapClassInst.heapFloat[r2 + numDefine8];
                        f21 = heapClassInst.heapFloat[r2 + numDefine9];
                        f22 = heapClassInst.heapFloat[r2 + numDefine6];
                        r5 = r5 >> numDefine2;
                        f23 = f15 * f7;
                        f24 = f16 * f6;
                        f18 = f18 + f19;
                        f19 = f17 * f9;
                        f25 = heapClassInst.heapFloat[r2 + numDefine10];
                        r5 = heapClassInst.heap32[r5 + numDefine2];
                        f18 = f18 + f19;
                        f7 = f20 * f7;
                        f6 = f21 * f6;
                        f19 = f23 + f24;
                        f23 = f22 * f9;
                        r9 = sp + numDefineNeg384;
                        f19 = f19 + f23;
                        f6 = f7 + f6;
                        f7 = f25 * f9;
                        f9 = f2 + f18;
                        f6 = f6 + f7;
                        f7 = f13 * f5;
                        f13 = f14 * f1;
                        r10 = r9 >> numDefine2;
                        f14 = f3 + f19;
                        heapClassInst.heapFloat[fp + numDefineNeg96] = f9;
                        f9 = f15 * f5;
                        f15 = f16 * f1;
                        f7 = f7 + f13;
                        f13 = f17 * f8;
                        f6 = f4 + f6;
                        heapClassInst.heapFloat[r10 + 1] = f14;
                        f7 = f7 + f13;
                        heapClassInst.heapFloat[r10 + numDefine2] = f6;
                        f6 = f20 * f5;
                        f13 = f21 * f1;
                        f9 = f9 + f15;
                        f14 = f22 * f8;
                        r11 = sp + numDefineNeg368;
                        f9 = f9 + f14;
                        f6 = f6 + f13;
                        f13 = f25 * f8;
                        f7 = f2 + f7;
                        heapClassInst.heap32[r10 + numDefine3] = 0;
                        f6 = f6 + f13;
                        r10 = r11 >> numDefine2;
                        f9 = f3 + f9;
                        heapClassInst.heapFloat[fp + numDefineNeg92] = f7;
                        f6 = f4 + f6;
                        heapClassInst.heapFloat[r10 + 1] = f9;
                        heapClassInst.heapFloat[r10 + numDefine2] = f6;
                        heapClassInst.heap32[r10 + numDefine3] = 0;
                        heapClassInst.heap32[g0] = commonVariable.rg0;
                        heapClassInst.heap32[g0 + 1] = r11;
                        heapClassInst.heap32[g0 + numDefine2] = r9;
                        heapClassInst.heap32[g0 + numDefine3] = r6;
                        functionTable.get(r5 >> numDefine2).accept(i7);
                        r3 = heapClassInst.heap32[r1];
                        r3 = r3 >> numDefine2;
                        r3 = heapClassInst.heap32[r3 + numDefine4];
                        heapClassInst.heap32[g0] = r0;
                        functionTable.get(r3 >> numDefine2).accept(i7);
                        f6 = heapClassInst.heapFloat[r8 + 1];
                        f7 = heapClassInst.heapFloat[fp + numDefineNeg228];
                        f9 = heapClassInst.heapFloat[r8 + numDefine2];
                        r5 = commonVariable.rg0 >> numDefine2;
                        f13 = heapClassInst.heapFloat[r2];
                        f14 = f7 - f5;
                        f15 = heapClassInst.heapFloat[r2 + 1];
                        f16 = f6 - f1;
                        f17 = heapClassInst.heapFloat[r2 + numDefine4];
                        f18 = heapClassInst.heapFloat[r2 + numDefine5];
                        r5 = heapClassInst.heap32[r5];
                        f19 = heapClassInst.heapFloat[r2 + numDefine2];
                        f20 = f9 - f8;
                        f21 = f13 * f14;
                        f22 = f15 * f16;
                        f23 = heapClassInst.heapFloat[r2 + numDefine8];
                        f24 = heapClassInst.heapFloat[r2 + numDefine9];
                        f25 = heapClassInst.heapFloat[r2 + numDefine6];
                        r5 = r5 >> numDefine2;
                        f26 = f17 * f14;
                        f27 = f18 * f16;
                        f21 = f21 + f22;
                        f22 = f19 * f20;
                        f28 = heapClassInst.heapFloat[r2 + numDefine10];
                        r5 = heapClassInst.heap32[r5 + numDefine2];
                        f21 = f21 + f22;
                        f14 = f23 * f14;
                        f16 = f24 * f16;
                        f22 = f26 + f27;
                        f26 = f25 * f20;
                        r8 = sp + numDefineNeg352;
                        f22 = f22 + f26;
                        f14 = f14 + f16;
                        f16 = f28 * f20;
                        f20 = f2 + f21;
                        f14 = f14 + f16;
                        f13 = f13 * f5;
                        f15 = f15 * f1;
                        r9 = r8 >> numDefine2;
                        f16 = f3 + f22;
                        heapClassInst.heapFloat[fp + numDefineNeg88] = f20;
                        f17 = f17 * f5;
                        f18 = f18 * f1;
                        f13 = f13 + f15;
                        f15 = f19 * f8;
                        f14 = f4 + f14;
                        heapClassInst.heapFloat[r9 + 1] = f16;
                        f13 = f13 + f15;
                        heapClassInst.heapFloat[r9 + numDefine2] = f14;
                        f14 = f23 * f5;
                        f15 = f24 * f1;
                        f16 = f17 + f18;
                        f17 = f25 * f8;
                        r10 = sp + numDefineNeg336;
                        f16 = f16 + f17;
                        f14 = f14 + f15;
                        f15 = f28 * f8;
                        f13 = f2 + f13;
                        heapClassInst.heap32[r9 + numDefine3] = 0;
                        f14 = f14 + f15;
                        r9 = r10 >> numDefine2;
                        f15 = f3 + f16;
                        heapClassInst.heapFloat[fp + numDefineNeg84] = f13;
                        f13 = f4 + f14;
                        heapClassInst.heapFloat[r9 + 1] = f15;
                        heapClassInst.heapFloat[r9 + numDefine2] = f13;
                        heapClassInst.heap32[r9 + numDefine3] = 0;
                        heapClassInst.heap32[g0] = commonVariable.rg0;
                        heapClassInst.heap32[g0 + 1] = r10;
                        heapClassInst.heap32[g0 + numDefine2] = r8;
                        heapClassInst.heap32[g0 + numDefine3] = r6;
                        functionTable.get(r5 >> numDefine2).accept(i7);
                        r3 = heapClassInst.heap32[r1];
                        r3 = r3 >> numDefine2;
                        r3 = heapClassInst.heap32[r3 + numDefine4];
                        heapClassInst.heap32[g0] = r0;
                        functionTable.get(r3 >> numDefine2).accept(i7);
                        r5 = commonVariable.rg0 >> numDefine2;
                        f13 = heapClassInst.heapFloat[r2];
                        f7 = f10 - f7;
                        f10 = heapClassInst.heapFloat[r2 + 1];
                        f6 = f11 - f6;
                        f11 = heapClassInst.heapFloat[r2 + numDefine4];
                        f14 = heapClassInst.heapFloat[r2 + numDefine5];
                        r5 = heapClassInst.heap32[r5];
                        f15 = heapClassInst.heapFloat[r2 + numDefine2];
                        f9 = f12 - f9;
                        f12 = f13 * f7;
                        f16 = f10 * f6;
                        f17 = heapClassInst.heapFloat[r2 + numDefine8];
                        f18 = heapClassInst.heapFloat[r2 + numDefine9];
                        f19 = heapClassInst.heapFloat[r2 + numDefine6];
                        r5 = r5 >> numDefine2;
                        f20 = f11 * f7;
                        f21 = f14 * f6;
                        f12 = f12 + f16;
                        f16 = f15 * f9;
                        f22 = heapClassInst.heapFloat[r2 + numDefine10];
                        r5 = heapClassInst.heap32[r5 + numDefine2];
                        f12 = f12 + f16;
                        f7 = f17 * f7;
                        f6 = f18 * f6;
                        f16 = f20 + f21;
                        f20 = f19 * f9;
                        r8 = sp + numDefineNeg320;
                        f16 = f16 + f20;
                        f6 = f7 + f6;
                        f7 = f22 * f9;
                        f9 = f2 + f12;
                        f6 = f6 + f7;
                        f7 = f13 * f5;
                        f10 = f10 * f1;
                        r9 = r8 >> numDefine2;
                        f12 = f3 + f16;
                        heapClassInst.heapFloat[fp + numDefineNeg80] = f9;
                        f9 = f11 * f5;
                        f11 = f14 * f1;
                        f7 = f7 + f10;
                        f10 = f15 * f8;
                        f6 = f4 + f6;
                        heapClassInst.heapFloat[r9 + 1] = f12;
                        f7 = f7 + f10;
                        heapClassInst.heapFloat[r9 + numDefine2] = f6;
                        f6 = f17 * f5;
                        f10 = f18 * f1;
                        f9 = f9 + f11;
                        f11 = f19 * f8;
                        r10 = sp + numDefineNeg304;
                        f9 = f9 + f11;
                        f6 = f6 + f10;
                        f10 = f22 * f8;
                        f7 = f2 + f7;
                        heapClassInst.heap32[r9 + numDefine3] = 0;
                        f6 = f6 + f10;
                        r9 = r10 >> numDefine2;
                        f9 = f3 + f9;
                        heapClassInst.heapFloat[fp + numDefineNeg76] = f7;
                        f6 = f4 + f6;
                        heapClassInst.heapFloat[r9 + 1] = f9;
                        heapClassInst.heapFloat[r9 + numDefine2] = f6;
                        heapClassInst.heap32[r9 + numDefine3] = 0;
                        heapClassInst.heap32[g0] = commonVariable.rg0;
                        heapClassInst.heap32[g0 + 1] = r10;
                        heapClassInst.heap32[g0 + numDefine2] = r8;
                        heapClassInst.heap32[g0 + numDefine3] = r6;
                        r3 = sp + numDefineNeg928;
                        functionTable.get(r5 >> numDefine2).accept(i7);
                        r5 = r3 >> numDefine2;
                        heapClassInst.heap32[fp + numDefineNeg232] = 0;
                        heapClassInst.heap32[r5 + 1] = 0;
                        r3 = (r3 + r7) | 0;
                        heapClassInst.heap32[r5 + numDefine2] = 0;
                        r3 = r3 >> numDefine2;
                        heapClassInst.heap32[r5 + numDefine3] = 0;
                        r7 = sp + numDefineNeg944;
                        heapClassInst.heap32[r3] = numDefine53216;
                        r3 = r7 >> numDefine2;
                        heapClassInst.heap32[fp + numDefineNeg236] = 0;
                        heapClassInst.heap32[r3 + 1] = 0;
                        r4 = (r7 + r4) | 0;
                        heapClassInst.heap32[r3 + numDefine2] = 0;
                        r4 = r4 >> numDefine2;
                        heapClassInst.heap32[r3 + numDefine3] = 0;
                        heapClassInst.heap32[r4] = numDefine53216;
                        r1 = heapClassInst.heap32[r1];
                        r1 = r1 >> numDefine2;
                        r1 = heapClassInst.heap32[r1 + numDefine4];
                        heapClassInst.heap32[g0] = r0;
                        functionTable.get(r1 >> numDefine2).accept(i7);
                        r1 = commonVariable.rg0 >> numDefine2;
                        r1 = heapClassInst.heap32[r1];
                        f6 = heapClassInst.heapFloat[r2];
                        f7 = heapClassInst.heapFloat[fp + numDefineNeg236];
                        f9 = heapClassInst.heapFloat[r2 + 1];
                        f10 = heapClassInst.heapFloat[r3 + 1];
                        f11 = heapClassInst.heapFloat[r2 + numDefine4];
                        f12 = heapClassInst.heapFloat[r2 + numDefine5];
                        r1 = r1 >> numDefine2;
                        f13 = heapClassInst.heapFloat[r2 + numDefine2];
                        f14 = heapClassInst.heapFloat[r3 + numDefine2];
                        f15 = f6 * f7;
                        f16 = f9 * f10;
                        f17 = heapClassInst.heapFloat[r2 + numDefine8];
                        f18 = heapClassInst.heapFloat[r2 + numDefine9];
                        f19 = heapClassInst.heapFloat[r2 + numDefine10];
                        f20 = heapClassInst.heapFloat[r2 + numDefine6];
                        r1 = heapClassInst.heap32[r1 + numDefine15];
                        f21 = f11 * f7;
                        f22 = f12 * f10;
                        f15 = f15 + f16;
                        f16 = f13 * f14;
                        r2 = sp + numDefineNeg288;
                        f7 = f17 * f7;
                        f10 = f18 * f10;
                        f21 = f21 + f22;
                        f22 = f20 * f14;
                        f15 = f15 + f16;
                        r3 = r2 >> numDefine2;
                        f7 = f7 + f10;
                        f10 = f19 * f14;
                        f14 = f21 + f22;
                        heapClassInst.heapFloat[fp + numDefineNeg72] = f15;
                        f7 = f7 + f10;
                        heapClassInst.heapFloat[r3 + 1] = f14;
                        heapClassInst.heapFloat[r3 + numDefine2] = f7;
                        heapClassInst.heap32[r3 + numDefine3] = 0;
                        f7 = heapClassInst.heapFloat[fp + numDefineNeg232];
                        f10 = heapClassInst.heapFloat[r5 + 1];
                        f14 = heapClassInst.heapFloat[r5 + numDefine2];
                        f15 = f6 * f7;
                        f16 = f9 * f10;
                        f21 = f11 * f7;
                        f22 = f12 * f10;
                        f15 = f15 + f16;
                        f16 = f13 * f14;
                        r3 = sp + numDefineNeg272;
                        f7 = f17 * f7;
                        f10 = f18 * f10;
                        f21 = f21 + f22;
                        f22 = f20 * f14;
                        f15 = f15 + f16;
                        f6 = f6 * f5;
                        f9 = f9 * f1;
                        r4 = r3 >> numDefine2;
                        f7 = f7 + f10;
                        f10 = f19 * f14;
                        f14 = f21 + f22;
                        heapClassInst.heapFloat[fp + numDefineNeg68] = f15;
                        f11 = f11 * f5;
                        f12 = f12 * f1;
                        f6 = f6 + f9;
                        f9 = f13 * f8;
                        f7 = f7 + f10;
                        heapClassInst.heapFloat[r4 + 1] = f14;
                        f6 = f6 + f9;
                        heapClassInst.heapFloat[r4 + numDefine2] = f7;
                        f5 = f17 * f5;
                        f1 = f18 * f1;
                        f7 = f11 + f12;
                        f9 = f20 * f8;
                        r5 = sp + numDefineNeg256;
                        f7 = f7 + f9;
                        f1 = f5 + f1;
                        f5 = f19 * f8;
                        f2 = f2 - f6;
                        heapClassInst.heap32[r4 + numDefine3] = 0;
                        f1 = f1 + f5;
                        r4 = r5 >> numDefine2;
                        f3 = f3 - f7;
                        heapClassInst.heapFloat[fp + numDefineNeg64] = f2;
                        f1 = f4 - f1;
                        heapClassInst.heapFloat[r4 + 1] = f3;
                        heapClassInst.heapFloat[r4 + numDefine2] = f1;
                        heapClassInst.heap32[r4 + numDefine3] = 0;
                        heapClassInst.heap32[g0] = commonVariable.rg0;
                        heapClassInst.heap32[g0 + 1] = r5;
                        heapClassInst.heap32[g0 + numDefine2] = r3;
                    } else {
                        if (r3 == numDefine13) {
                            r3 = heapClassInst.heap32[r5];
                            r3 = r3 >> numDefine2;
                            r7 = heapClassInst.heap32[r5 + numDefine13];
                            r3 = heapClassInst.heap32[r3 + numDefine21];
                            heapClassInst.heap32[g0] = r2;
                            functionTable.get(r3 >> numDefine2).accept(i7);
                            f0 = (float) commonVariable.fg0;
                            r3 = sp + numDefineNeg240;
                            f1 = heapClassInst.heapFloat[r5 + numDefine8];
                            f2 = heapClassInst.heapFloat[r5 + numDefine9];
                            f3 = heapClassInst.heapFloat[r5 + numDefine7];
                            r8 = r3 >> numDefine2;
                            heapClassInst.heap32[r8 + numDefine3] = heapClassInst.heap32[r5 + numDefine10];
                            r9 = heapClassInst.heap32[r5];
                            r9 = r9 >> numDefine2;
                            r9 = heapClassInst.heap32[r9 + numDefine11];
                            heapClassInst.heap32[g0] = r2;
                            functionTable.get(r9 >> numDefine2).accept(i7);
                            f4 = (float) commonVariable.fg0;
                            r9 = heapClassInst.heap32[r5];
                            r9 = r9 >> numDefine2;
                            r9 = heapClassInst.heap32[r9 + numDefine11];
                            heapClassInst.heap32[g0] = r2;
                            functionTable.get(r9 >> numDefine2).accept(i7);
                            f5 = (float) commonVariable.fg0;
                            r5 = heapClassInst.heap32[r5];
                            r5 = r5 >> numDefine2;
                            r5 = heapClassInst.heap32[r5 + numDefine11];
                            heapClassInst.heap32[g0] = r2;
                            functionTable.get(r5 >> numDefine2).accept(i7);
                            f3 = f3 + (float) commonVariable.fg0;
                            r2 = r7 << numDefine2;
                            f1 = f1 + f5;
                            heapClassInst.heapFloat[fp + numDefineNeg60] = f3;
                            r3 = (r3 + r2) | 0;
                            f2 = f2 + f4;
                            heapClassInst.heapFloat[r8 + 1] = f1;
                            r3 = r3 >> numDefine2;
                            heapClassInst.heapFloat[r8 + numDefine2] = f2;
                            r4 = r4 >> numDefine2;
                            f1 = heapClassInst.heapFloat[r3];
                            f2 = heapClassInst.heapFloat[r4 + numDefine12];
                            f3 = heapClassInst.heapFloat[r4 + numDefine13];
                            f4 = heapClassInst.heapFloat[r4 + numDefine14];
                            r3 = sp + numDefineNeg960;
                            r5 = r3 >> numDefine2;
                            heapClassInst.heap32[fp + numDefineNeg240] = 0;
                            heapClassInst.heap32[r5 + 1] = 0;
                            r3 = (r3 + r2) | 0;
                            heapClassInst.heap32[r5 + numDefine2] = 0;
                            r3 = r3 >> numDefine2;
                            heapClassInst.heap32[r5 + numDefine3] = 0;
                            r8 = sp + numDefineNeg976;
                            heapClassInst.heapFloat[r3] = f1;
                            r3 = (r7 + 1) | 0;
                            r3 = r3 % numDefine3 | 0;
                            r7 = r8 >> numDefine2;
                            heapClassInst.heap32[fp + numDefineNeg244] = 0;
                            heapClassInst.heap32[r7 + 1] = 0;
                            r3 = r3 << numDefine2;
                            r8 = (r8 + r3) | 0;
                            heapClassInst.heap32[r7 + numDefine2] = 0;
                            r8 = r8 >> numDefine2;
                            heapClassInst.heap32[r7 + numDefine3] = 0;
                            heapClassInst.heapFloat[r8] = f0;
                            r8 = heapClassInst.heap32[r1];
                            r8 = r8 >> numDefine2;
                            r8 = heapClassInst.heap32[r8 + numDefine4];
                            heapClassInst.heap32[g0] = r0;
                            functionTable.get(r8 >> numDefine2).accept(i7);
                            f1 = heapClassInst.heapFloat[r5 + 1];
                            f5 = heapClassInst.heapFloat[r7 + 1];
                            f6 = heapClassInst.heapFloat[fp + numDefineNeg240];
                            f7 = heapClassInst.heapFloat[fp + numDefineNeg244];
                            r9 = commonVariable.rg0 >> numDefine2;
                            f8 = heapClassInst.heapFloat[r5 + numDefine2];
                            f9 = heapClassInst.heapFloat[r7 + numDefine2];
                            f10 = f7 - f6;
                            f11 = heapClassInst.heapFloat[r4];
                            f12 = f5 - f1;
                            f13 = heapClassInst.heapFloat[r4 + 1];
                            r5 = heapClassInst.heap32[r9];
                            f14 = heapClassInst.heapFloat[r4 + numDefine4];
                            f15 = heapClassInst.heapFloat[r4 + numDefine5];
                            f16 = f11 * f10;
                            f17 = f13 * f12;
                            f18 = f9 - f8;
                            f19 = heapClassInst.heapFloat[r4 + numDefine2];
                            r5 = r5 >> numDefine2;
                            f20 = heapClassInst.heapFloat[r4 + numDefine8];
                            f21 = heapClassInst.heapFloat[r4 + numDefine9];
                            f22 = heapClassInst.heapFloat[r4 + numDefine6];
                            f23 = f14 * f10;
                            f24 = f15 * f12;
                            f16 = f16 + f17;
                            f17 = f19 * f18;
                            f16 = f16 + f17;
                            f17 = heapClassInst.heapFloat[r4 + numDefine10];
                            r5 = heapClassInst.heap32[r5 + numDefine2];
                            f10 = f20 * f10;
                            f12 = f21 * f12;
                            f23 = f23 + f24;
                            f24 = f22 * f18;
                            f25 = f6 + f7;
                            f26 = f1 + f5;
                            r7 = sp + numDefineNeg224;
                            f23 = f23 + f24;
                            f10 = f10 + f12;
                            f12 = f17 * f18;
                            f16 = f2 + f16;
                            f18 = f8 + f9;
                            f10 = f10 + f12;
                            f11 = f11 * f25;
                            f12 = f13 * f26;
                            r9 = r7 >> numDefine2;
                            f13 = f3 + f23;
                            heapClassInst.heapFloat[fp + numDefineNeg56] = f16;
                            f14 = f14 * f25;
                            f15 = f15 * f26;
                            f11 = f11 + f12;
                            f12 = f19 * f18;
                            f10 = f4 + f10;
                            heapClassInst.heapFloat[r9 + 1] = f13;
                            f11 = f11 + f12;
                            heapClassInst.heapFloat[r9 + numDefine2] = f10;
                            f10 = f20 * f25;
                            f12 = f21 * f26;
                            f13 = f14 + f15;
                            f14 = f22 * f18;
                            r10 = sp + numDefineNeg208;
                            f13 = f13 + f14;
                            f10 = f10 + f12;
                            f12 = f17 * f18;
                            f11 = f2 + f11;
                            heapClassInst.heap32[r9 + numDefine3] = 0;
                            f10 = f10 + f12;
                            r9 = r10 >> numDefine2;
                            f12 = f3 + f13;
                            heapClassInst.heapFloat[fp + numDefineNeg52] = f11;
                            f10 = f4 + f10;
                            heapClassInst.heapFloat[r9 + 1] = f12;
                            heapClassInst.heapFloat[r9 + numDefine2] = f10;
                            heapClassInst.heap32[r9 + numDefine3] = 0;
                            heapClassInst.heap32[g0] = commonVariable.rg0;
                            heapClassInst.heap32[g0 + 1] = r10;
                            heapClassInst.heap32[g0 + numDefine2] = r7;
                            heapClassInst.heap32[g0 + numDefine3] = r6;
                            functionTable.get(r5 >> numDefine2).accept(i7);
                            r5 = heapClassInst.heap32[r1];
                            r5 = r5 >> numDefine2;
                            r5 = heapClassInst.heap32[r5 + numDefine4];
                            heapClassInst.heap32[g0] = r0;
                            functionTable.get(r5 >> numDefine2).accept(i7);
                            f10 = -f6;
                            f11 = -f1;
                            f12 = -f8;
                            r7 = commonVariable.rg0 >> numDefine2;
                            f10 = f10 - f7;
                            f13 = heapClassInst.heapFloat[r4];
                            f11 = f11 - f5;
                            f14 = heapClassInst.heapFloat[r4 + 1];
                            r7 = heapClassInst.heap32[r7];
                            f15 = heapClassInst.heapFloat[r4 + numDefine4];
                            f16 = heapClassInst.heapFloat[r4 + numDefine5];
                            f17 = f13 * f10;
                            f18 = f14 * f11;
                            f12 = f12 - f9;
                            f19 = heapClassInst.heapFloat[r4 + numDefine2];
                            r7 = r7 >> numDefine2;
                            f20 = heapClassInst.heapFloat[r4 + numDefine8];
                            f21 = heapClassInst.heapFloat[r4 + numDefine9];
                            f22 = heapClassInst.heapFloat[r4 + numDefine6];
                            f23 = f15 * f10;
                            f24 = f16 * f11;
                            f17 = f17 + f18;
                            f18 = f19 * f12;
                            f17 = f17 + f18;
                            f18 = heapClassInst.heapFloat[r4 + numDefine10];
                            r7 = heapClassInst.heap32[r7 + numDefine2];
                            f10 = f20 * f10;
                            f11 = f21 * f11;
                            f23 = f23 + f24;
                            f24 = f22 * f12;
                            f7 = f6 - f7;
                            f5 = f1 - f5;
                            r8 = sp + numDefineNeg192;
                            f23 = f23 + f24;
                            f10 = f10 + f11;
                            f11 = f18 * f12;
                            f12 = f2 + f17;
                            f9 = f8 - f9;
                            f10 = f10 + f11;
                            f11 = f13 * f7;
                            f13 = f14 * f5;
                            r9 = r8 >> numDefine2;
                            f14 = f3 + f23;
                            heapClassInst.heapFloat[fp + numDefineNeg48] = f12;
                            f12 = f15 * f7;
                            f15 = f16 * f5;
                            f11 = f11 + f13;
                            f13 = f19 * f9;
                            f10 = f4 + f10;
                            heapClassInst.heapFloat[r9 + 1] = f14;
                            f11 = f11 + f13;
                            heapClassInst.heapFloat[r9 + numDefine2] = f10;
                            f7 = f20 * f7;
                            f5 = f21 * f5;
                            f10 = f12 + f15;
                            f12 = f22 * f9;
                            r10 = sp + numDefineNeg176;
                            f10 = f10 + f12;
                            f5 = f7 + f5;
                            f7 = f18 * f9;
                            f9 = f2 + f11;
                            heapClassInst.heap32[r9 + numDefine3] = 0;
                            f5 = f5 + f7;
                            r9 = r10 >> numDefine2;
                            f7 = f3 + f10;
                            heapClassInst.heapFloat[fp + numDefineNeg44] = f9;
                            f5 = f4 + f5;
                            heapClassInst.heapFloat[r9 + 1] = f7;
                            heapClassInst.heapFloat[r9 + numDefine2] = f5;
                            heapClassInst.heap32[r9 + numDefine3] = 0;
                            heapClassInst.heap32[g0] = commonVariable.rg0;
                            heapClassInst.heap32[g0 + 1] = r10;
                            heapClassInst.heap32[g0 + numDefine2] = r8;
                            heapClassInst.heap32[g0 + numDefine3] = r6;
                            r5 = sp + numDefineNeg992;
                            functionTable.get(r7 >> numDefine2).accept(i7);
                            r7 = r5 >> numDefine2;
                            heapClassInst.heap32[fp + numDefineNeg248] = 0;
                            heapClassInst.heap32[r7 + 1] = 0;
                            r2 = (r5 + r2) | 0;
                            heapClassInst.heap32[r7 + numDefine2] = 0;
                            r2 = r2 >> numDefine2;
                            heapClassInst.heap32[r7 + numDefine3] = 0;
                            r5 = sp + numDefineNeg1008;
                            heapClassInst.heap32[r2] = numDefine53216;
                            r2 = r5 >> numDefine2;
                            heapClassInst.heap32[fp + numDefineNeg252] = 0;
                            heapClassInst.heap32[r2 + 1] = 0;
                            r3 = (r5 + r3) | 0;
                            heapClassInst.heap32[r2 + numDefine2] = 0;
                            r3 = r3 >> numDefine2;
                            heapClassInst.heap32[r2 + numDefine3] = 0;
                            heapClassInst.heap32[r3] = numDefine53216;
                            r3 = heapClassInst.heap32[r1];
                            r3 = r3 >> numDefine2;
                            r3 = heapClassInst.heap32[r3 + numDefine4];
                            heapClassInst.heap32[g0] = r0;
                            functionTable.get(r3 >> numDefine2).accept(i7);
                            r5 = commonVariable.rg0 >> numDefine2;
                            r5 = heapClassInst.heap32[r5];
                            f5 = heapClassInst.heapFloat[r4];
                            f7 = heapClassInst.heapFloat[fp + numDefineNeg252];
                            f9 = heapClassInst.heapFloat[r4 + 1];
                            f10 = heapClassInst.heapFloat[r2 + 1];
                            f11 = heapClassInst.heapFloat[r4 + numDefine4];
                            f12 = heapClassInst.heapFloat[r4 + numDefine5];
                            r5 = r5 >> numDefine2;
                            f13 = heapClassInst.heapFloat[r4 + numDefine2];
                            f14 = heapClassInst.heapFloat[r2 + numDefine2];
                            f15 = f5 * f7;
                            f16 = f9 * f10;
                            f17 = heapClassInst.heapFloat[r4 + numDefine8];
                            f18 = heapClassInst.heapFloat[r4 + numDefine9];
                            f19 = heapClassInst.heapFloat[r4 + numDefine10];
                            f20 = heapClassInst.heapFloat[r4 + numDefine6];
                            r2 = heapClassInst.heap32[r5 + numDefine15];
                            f21 = f11 * f7;
                            f22 = f12 * f10;
                            f15 = f15 + f16;
                            f16 = f13 * f14;
                            r5 = sp + numDefineNeg160;
                            f23 = f17 * f7;
                            f24 = f18 * f10;
                            f21 = f21 + f22;
                            f22 = f20 * f14;
                            f15 = f15 + f16;
                            r8 = r5 >> numDefine2;
                            f16 = f23 + f24;
                            f23 = f19 * f14;
                            f21 = f21 + f22;
                            heapClassInst.heapFloat[fp + numDefineNeg40] = f15;
                            f15 = f16 + f23;
                            heapClassInst.heapFloat[r8 + 1] = f21;
                            heapClassInst.heapFloat[r8 + numDefine2] = f15;
                            heapClassInst.heap32[r8 + numDefine3] = 0;
                            f15 = heapClassInst.heapFloat[fp + numDefineNeg248];
                            f16 = heapClassInst.heapFloat[r7 + 1];
                            f21 = heapClassInst.heapFloat[r7 + numDefine2];
                            f22 = f5 * f15;
                            f23 = f9 * f16;
                            f24 = f11 * f15;
                            f25 = f12 * f16;
                            f22 = f22 + f23;
                            f23 = f13 * f21;
                            r7 = sp + numDefineNeg144;
                            f26 = f17 * f15;
                            f27 = f18 * f16;
                            f24 = f24 + f25;
                            f25 = f20 * f21;
                            f22 = f22 + f23;
                            f5 = f5 * f6;
                            f9 = f9 * f1;
                            r8 = r7 >> numDefine2;
                            f23 = f26 + f27;
                            f26 = f19 * f21;
                            f24 = f24 + f25;
                            heapClassInst.heapFloat[fp + numDefineNeg36] = f22;
                            f11 = f11 * f6;
                            f12 = f12 * f1;
                            f5 = f5 + f9;
                            f9 = f13 * f8;
                            f13 = f23 + f26;
                            heapClassInst.heapFloat[r8 + 1] = f24;
                            f5 = f5 + f9;
                            heapClassInst.heapFloat[r8 + numDefine2] = f13;
                            f9 = f17 * f6;
                            f13 = f18 * f1;
                            f11 = f11 + f12;
                            f12 = f20 * f8;
                            r9 = sp + numDefineNeg128;
                            f11 = f11 + f12;
                            f9 = f9 + f13;
                            f12 = f19 * f8;
                            f5 = f2 - f5;
                            heapClassInst.heap32[r8 + numDefine3] = 0;
                            f9 = f9 + f12;
                            r8 = r9 >> numDefine2;
                            f11 = f3 - f11;
                            heapClassInst.heapFloat[fp + numDefineNeg32] = f5;
                            f5 = f4 - f9;
                            heapClassInst.heapFloat[r8 + 1] = f11;
                            heapClassInst.heapFloat[r8 + numDefine2] = f5;
                            heapClassInst.heap32[r8 + numDefine3] = 0;
                            heapClassInst.heap32[g0] = commonVariable.rg0;
                            heapClassInst.heap32[g0 + 1] = r9;
                            heapClassInst.heap32[g0 + numDefine2] = r7;
                            heapClassInst.heap32[g0 + numDefine3] = r5;
                            heapClassInst.heapFloat[g0 + numDefine4] = f0;
                            heapClassInst.heapFloat[g0 + numDefine5] = f0;
                            heapClassInst.heap32[g0 + numDefine6] = 0;
                            heapClassInst.heap32[g0 + numDefine7] = numDefine18619;
                            heapClassInst.heap32[g0 + numDefine8] = r6;
                            heapClassInst.heap32[g0 + numDefine9] = 0;
                            heapClassInst.heap32[g0 + numDefine10] = numDefine16192;
                            functionTable.get(r2 >> numDefine2).accept(i7);
                            r1 = heapClassInst.heap32[r1];
                            r1 = r1 >> numDefine2;
                            r1 = heapClassInst.heap32[r1 + numDefine4];
                            heapClassInst.heap32[g0] = r0;
                            functionTable.get(r1 >> numDefine2).accept(i7);
                            r1 = commonVariable.rg0 >> numDefine2;
                            f5 = heapClassInst.heapFloat[r4];
                            f9 = heapClassInst.heapFloat[r4 + 1];
                            r1 = heapClassInst.heap32[r1];
                            f11 = heapClassInst.heapFloat[r4 + numDefine4];
                            f12 = heapClassInst.heapFloat[r4 + numDefine5];
                            f13 = heapClassInst.heapFloat[r4 + numDefine2];
                            r1 = r1 >> numDefine2;
                            f17 = f5 * f7;
                            f18 = f9 * f10;
                            f19 = heapClassInst.heapFloat[r4 + numDefine8];
                            f20 = heapClassInst.heapFloat[r4 + numDefine9];
                            f22 = heapClassInst.heapFloat[r4 + numDefine10];
                            f23 = heapClassInst.heapFloat[r4 + numDefine6];
                            r1 = heapClassInst.heap32[r1 + numDefine15];
                            f24 = f11 * f7;
                            f25 = f12 * f10;
                            f17 = f17 + f18;
                            f18 = f13 * f14;
                            r2 = sp + numDefineNeg112;
                            f7 = f19 * f7;
                            f10 = f20 * f10;
                            f24 = f24 + f25;
                            f25 = f23 * f14;
                            f17 = f17 + f18;
                            r3 = r2 >> numDefine2;
                            f7 = f7 + f10;
                            f10 = f22 * f14;
                            f14 = f24 + f25;
                            heapClassInst.heapFloat[fp + numDefineNeg28] = f17;
                            f17 = f5 * f15;
                            f18 = f9 * f16;
                            f7 = f7 + f10;
                            heapClassInst.heapFloat[r3 + 1] = f14;
                            heapClassInst.heapFloat[r3 + numDefine2] = f7;
                            f7 = f11 * f15;
                            f10 = f12 * f16;
                            f14 = f17 + f18;
                            f17 = f13 * f21;
                            r4 = sp + numDefineNeg96;
                            f15 = f19 * f15;
                            f16 = f20 * f16;
                            f7 = f7 + f10;
                            f10 = f23 * f21;
                            f14 = f14 + f17;
                            heapClassInst.heap32[r3 + numDefine3] = 0;
                            f5 = f5 * f6;
                            f9 = f9 * f1;
                            r3 = r4 >> numDefine2;
                            f15 = f15 + f16;
                            f16 = f22 * f21;
                            f7 = f7 + f10;
                            heapClassInst.heapFloat[fp + numDefineNeg24] = f14;
                            f10 = f11 * f6;
                            f11 = f12 * f1;
                            f5 = f5 + f9;
                            f9 = f13 * f8;
                            f12 = f15 + f16;
                            heapClassInst.heapFloat[r3 + 1] = f7;
                            f5 = f5 + f9;
                            heapClassInst.heapFloat[r3 + numDefine2] = f12;
                            f6 = f19 * f6;
                            f1 = f20 * f1;
                            f7 = f10 + f11;
                            f9 = f23 * f8;
                            r5 = sp + numDefineNeg80;
                            f7 = f7 + f9;
                            f1 = f6 + f1;
                            f6 = f22 * f8;
                            f2 = f2 + f5;
                            heapClassInst.heap32[r3 + numDefine3] = 0;
                            f1 = f1 + f6;
                            r3 = r5 >> numDefine2;
                            f3 = f3 + f7;
                            heapClassInst.heapFloat[fp + numDefineNeg20] = f2;
                            f1 = f4 + f1;
                            heapClassInst.heapFloat[r3 + 1] = f3;
                            heapClassInst.heapFloat[r3 + numDefine2] = f1;
                            heapClassInst.heap32[r3 + numDefine3] = 0;
                            heapClassInst.heap32[g0] = commonVariable.rg0;
                            heapClassInst.heap32[g0 + 1] = r5;
                            heapClassInst.heap32[g0 + numDefine2] = r4;
                        } else {
                            label = numDefine32;
                            break repeat1;
                        }
                    }
                    heapClassInst.heap32[g0 + numDefine3] = r2;
                    heapClassInst.heapFloat[g0 + numDefine4] = f0;
                    heapClassInst.heapFloat[g0 + numDefine5] = f0;
                    heapClassInst.heap32[g0 + numDefine6] = 0;
                    heapClassInst.heap32[g0 + numDefine7] = numDefine18619;
                    heapClassInst.heap32[g0 + numDefine8] = r6;
                    heapClassInst.heap32[g0 + numDefine9] = 0;
                    heapClassInst.heap32[g0 + numDefine10] = numDefine16192;
                    functionTable.get(r1 >> numDefine2).accept(i7);
                    
                }
            } else {
                if (r3 > numDefine8) {
                    if (r3 == numDefine9) {
                        r2 = heapClassInst.heap32[r5 + numDefine23];
                        r3 = (r2 + -1) | 0;
                        if (r3 < 0) {
                            label = numDefine40;
                            break repeat1;
                        } else {
                            r3 = 1;
                            r2 = (r3 - r2) | 0;
                            repeat32:
                            while (true) {
                                r3 = r2;
                                r2 = heapClassInst.heap32[r5 + numDefine25];
                                r7 = r3 << numDefine4;
                                r8 = heapClassInst.heap32[r1];
                                r2 = (r2 - r7) | 0;
                                r2 = r2 >> numDefine2;
                                r7 = r8 >> numDefine2;
                                r7 = heapClassInst.heap32[r7 + numDefine4];
                                f0 = heapClassInst.heapFloat[r2];
                                f1 = heapClassInst.heapFloat[r2 + 1];
                                f2 = heapClassInst.heapFloat[r2 + numDefine2];
                                heapClassInst.heap32[g0] = r0;
                                functionTable.get(r7 >> numDefine2).accept(i7);
                                r7 = r4 >> numDefine2;
                                r8 = commonVariable.rg0 >> numDefine2;
                                r8 = heapClassInst.heap32[r8];
                                f3 = heapClassInst.heapFloat[r7 + 1];
                                f4 = 0;
                                f5 = heapClassInst.heapFloat[r7];
                                f6 = heapClassInst.heapFloat[r7 + numDefine2];
                                r8 = r8 >> numDefine2;
                                f7 = f3 * f4;
                                f8 = f5 * f4;
                                f9 = heapClassInst.heapFloat[r7 + numDefine8];
                                f10 = heapClassInst.heapFloat[r7 + numDefine9];
                                f11 = heapClassInst.heapFloat[r7 + numDefine10];
                                f12 = heapClassInst.heapFloat[r7 + numDefine4];
                                f13 = heapClassInst.heapFloat[r7 + numDefine5];
                                f14 = heapClassInst.heapFloat[r7 + numDefine6];
                                r8 = heapClassInst.heap32[r8 + numDefine4];
                                f15 = f5 + f7;
                                f16 = f6 * f4;
                                f17 = heapClassInst.heapFloat[r7 + numDefine14];
                                f18 = heapClassInst.heapFloat[r7 + numDefine13];
                                f19 = heapClassInst.heapFloat[r7 + numDefine12];
                                r7 = sp + numDefineNeg608;
                                f20 = f8 + f3;
                                f15 = f15 + f16;
                                f7 = f8 + f7;
                                r9 = r7 >> numDefine2;
                                f8 = f20 + f16;
                                heapClassInst.heapFloat[fp + numDefineNeg152] = f15;
                                f15 = f13 * f4;
                                f7 = f7 + f6;
                                heapClassInst.heapFloat[r9 + 1] = f8;
                                f8 = f12 * f4;
                                heapClassInst.heapFloat[r9 + numDefine2] = f7;
                                f7 = f12 + f15;
                                f16 = f14 * f4;
                                f20 = f8 + f13;
                                f7 = f7 + f16;
                                heapClassInst.heap32[r9 + numDefine3] = 0;
                                f8 = f8 + f15;
                                f15 = f20 + f16;
                                heapClassInst.heapFloat[r9 + numDefine4] = f7;
                                f7 = f10 * f4;
                                f8 = f8 + f14;
                                heapClassInst.heapFloat[r9 + numDefine5] = f15;
                                f15 = f9 * f4;
                                heapClassInst.heapFloat[r9 + numDefine6] = f8;
                                f8 = f9 + f7;
                                f4 = f11 * f4;
                                f16 = f15 + f10;
                                f8 = f8 + f4;
                                heapClassInst.heap32[r9 + numDefine7] = 0;
                                f7 = f15 + f7;
                                f5 = f5 * f0;
                                f3 = f3 * f1;
                                f4 = f16 + f4;
                                heapClassInst.heapFloat[r9 + numDefine8] = f8;
                                f8 = f12 * f0;
                                f12 = f13 * f1;
                                f3 = f5 + f3;
                                f5 = f6 * f2;
                                f6 = f7 + f11;
                                heapClassInst.heapFloat[r9 + numDefine9] = f4;
                                f3 = f3 + f5;
                                heapClassInst.heapFloat[r9 + numDefine10] = f6;
                                f0 = f9 * f0;
                                f1 = f10 * f1;
                                f4 = f8 + f12;
                                f5 = f14 * f2;
                                f4 = f4 + f5;
                                f0 = f0 + f1;
                                f1 = f11 * f2;
                                f2 = f3 + f19;
                                heapClassInst.heap32[r9 + numDefine11] = 0;
                                f0 = f0 + f1;
                                f1 = f4 + f18;
                                heapClassInst.heapFloat[r9 + numDefine12] = f2;
                                f0 = f0 + f17;
                                heapClassInst.heapFloat[r9 + numDefine13] = f1;
                                heapClassInst.heapFloat[r9 + numDefine14] = f0;
                                heapClassInst.heap32[r9 + numDefine15] = 0;
                                r9 = heapClassInst.heap32[r5 + numDefine30];
                                r10 = r3 << numDefine2;
                                r9 = (r9 - r10) | 0;
                                r9 = r9 >> numDefine2;
                                f0 = heapClassInst.heapFloat[r9];
                                heapClassInst.heap32[g0] = commonVariable.rg0;
                                heapClassInst.heapFloat[g0 + 1] = f0;
                                heapClassInst.heap32[g0 + numDefine2] = r7;
                                heapClassInst.heap32[g0 + numDefine3] = r6;
                                r2 = (r3 + 1) | 0;
                                functionTable.get(r8 >> numDefine2).accept(i7);
                                if (r3 == 0) {
                                    label = numDefine40;
                                    break repeat1;
                                } else {
                                    continue repeat32;
                                }
                            }
                        }
                    } else {
                        if (r3 == numDefine10) {
                            r3 = heapClassInst.heap32[r5 + numDefine13];
                            r5 = (r3 + numDefine2) | 0;
                            r5 = r5 % numDefine3 | 0;
                            r7 = r3 << numDefine2;
                            r2 = (r2 + numDefine28) | 0;
                            r5 = r5 << numDefine2;
                            r8 = (r2 + r7) | 0;
                            r2 = (r2 + r5) | 0;
                            r8 = r8 >> numDefine2;
                            r2 = r2 >> numDefine2;
                            f0 = heapClassInst.heapFloat[r8];
                            f1 = heapClassInst.heapFloat[r2];
                            r2 = sp + numDefineNeg720;
                            r8 = r2 >> numDefine2;
                            heapClassInst.heap32[fp + numDefineNeg180] = 0;
                            heapClassInst.heap32[r8 + 1] = 0;
                            r9 = (r2 + r7) | 0;
                            heapClassInst.heap32[r8 + numDefine2] = 0;
                            r9 = r9 >> numDefine2;
                            f2 = -f0;
                            heapClassInst.heap32[r8 + numDefine3] = 0;
                            r10 = sp + numDefineNeg736;
                            heapClassInst.heapFloat[r9] = f2;
                            heapClassInst.heap32[fp + numDefineNeg184] = 0;
                            r9 = r10 >> numDefine2;
                            heapClassInst.heap32[r9 + 1] = 0;
                            r7 = (r10 + r7) | 0;
                            heapClassInst.heap32[r9 + numDefine2] = 0;
                            r7 = r7 >> numDefine2;
                            heapClassInst.heap32[r9 + numDefine3] = 0;
                            heapClassInst.heapFloat[r7] = f0;
                            r4 = r4 >> numDefine2;
                            f0 = heapClassInst.heapFloat[r4];
                            r7 = sp + numDefineNeg800;
                            heapClassInst.heapFloat[fp + numDefineNeg200] = f0;
                            r11 = r7 >> numDefine2;
                            f2 = heapClassInst.heapFloat[r4 + 1];
                            heapClassInst.heapFloat[r11 + 1] = f2;
                            f3 = heapClassInst.heapFloat[r4 + numDefine2];
                            heapClassInst.heapFloat[r11 + numDefine2] = f3;
                            heapClassInst.heap32[r11 + numDefine3] = heapClassInst.heap32[r4 + numDefine3];
                            f4 = heapClassInst.heapFloat[r4 + numDefine4];
                            heapClassInst.heapFloat[r11 + numDefine4] = f4;
                            f5 = heapClassInst.heapFloat[r4 + numDefine5];
                            heapClassInst.heapFloat[r11 + numDefine5] = f5;
                            f6 = heapClassInst.heapFloat[r4 + numDefine6];
                            heapClassInst.heapFloat[r11 + numDefine6] = f6;
                            heapClassInst.heap32[r11 + numDefine7] = heapClassInst.heap32[r4 + numDefine7];
                            f7 = heapClassInst.heapFloat[r4 + numDefine8];
                            heapClassInst.heapFloat[r11 + numDefine8] = f7;
                            f8 = heapClassInst.heapFloat[r4 + numDefine9];
                            heapClassInst.heapFloat[r11 + numDefine9] = f8;
                            f9 = heapClassInst.heapFloat[r4 + numDefine10];
                            heapClassInst.heapFloat[r11 + numDefine10] = f9;
                            heapClassInst.heap32[r11 + numDefine11] = heapClassInst.heap32[r4 + numDefine11];
                            f10 = heapClassInst.heapFloat[fp + numDefineNeg180];
                            f11 = heapClassInst.heapFloat[r8 + 1];
                            f12 = heapClassInst.heapFloat[r8 + numDefine2];
                            f0 = f0 * f10;
                            f2 = f2 * f11;
                            f4 = f4 * f10;
                            f5 = f5 * f11;
                            f0 = f0 + f2;
                            f2 = f3 * f12;
                            f3 = f7 * f10;
                            f7 = f8 * f11;
                            f4 = f4 + f5;
                            f5 = f6 * f12;
                            f0 = f0 + f2;
                            f2 = heapClassInst.heapFloat[r4 + numDefine12];
                            f6 = heapClassInst.heapFloat[r4 + numDefine13];
                            f8 = heapClassInst.heapFloat[r4 + numDefine14];
                            f4 = f4 + f5;
                            f3 = f3 + f7;
                            f5 = f9 * f12;
                            f0 = f0 + f2;
                            f2 = f3 + f5;
                            f3 = f4 + f6;
                            heapClassInst.heapFloat[r11 + numDefine12] = f0;
                            f0 = f2 + f8;
                            heapClassInst.heapFloat[r11 + numDefine13] = f3;
                            heapClassInst.heapFloat[r11 + numDefine14] = f0;
                            heapClassInst.heap32[r11 + numDefine15] = 0;
                            r11 = heapClassInst.heap32[r1];
                            r11 = r11 >> numDefine2;
                            r11 = heapClassInst.heap32[r11 + numDefine4];
                            heapClassInst.heap32[g0] = r0;
                            functionTable.get(r11 >> numDefine2).accept(i7);
                            r12 = commonVariable.rg0 >> numDefine2;
                            r12 = heapClassInst.heap32[r12];
                            r12 = r12 >> numDefine2;
                            r12 = heapClassInst.heap32[r12 + numDefine4];
                            heapClassInst.heap32[g0] = commonVariable.rg0;
                            heapClassInst.heapFloat[g0 + 1] = f1;
                            heapClassInst.heap32[g0 + numDefine2] = r7;
                            heapClassInst.heap32[g0 + numDefine3] = r6;
                            functionTable.get(r12 >> numDefine2).accept(i7);
                            f0 = heapClassInst.heapFloat[r4];
                            r7 = sp + numDefineNeg864;
                            heapClassInst.heapFloat[fp + numDefineNeg216] = f0;
                            r11 = r7 >> numDefine2;
                            f2 = heapClassInst.heapFloat[r4 + 1];
                            heapClassInst.heapFloat[r11 + 1] = f2;
                            f3 = heapClassInst.heapFloat[r4 + numDefine2];
                            heapClassInst.heapFloat[r11 + numDefine2] = f3;
                            heapClassInst.heap32[r11 + numDefine3] = heapClassInst.heap32[r4 + numDefine3];
                            f4 = heapClassInst.heapFloat[r4 + numDefine4];
                            heapClassInst.heapFloat[r11 + numDefine4] = f4;
                            f5 = heapClassInst.heapFloat[r4 + numDefine5];
                            heapClassInst.heapFloat[r11 + numDefine5] = f5;
                            f6 = heapClassInst.heapFloat[r4 + numDefine6];
                            heapClassInst.heapFloat[r11 + numDefine6] = f6;
                            heapClassInst.heap32[r11 + numDefine7] = heapClassInst.heap32[r4 + numDefine7];
                            f7 = heapClassInst.heapFloat[r4 + numDefine8];
                            heapClassInst.heapFloat[r11 + numDefine8] = f7;
                            f8 = heapClassInst.heapFloat[r4 + numDefine9];
                            heapClassInst.heapFloat[r11 + numDefine9] = f8;
                            f9 = heapClassInst.heapFloat[r4 + numDefine10];
                            heapClassInst.heapFloat[r11 + numDefine10] = f9;
                            heapClassInst.heap32[r11 + numDefine11] = heapClassInst.heap32[r4 + numDefine11];
                            f10 = heapClassInst.heapFloat[fp + numDefineNeg184];
                            f11 = heapClassInst.heapFloat[r9 + 1];
                            f12 = heapClassInst.heapFloat[r9 + numDefine2];
                            f0 = f0 * f10;
                            f2 = f2 * f11;
                            f4 = f4 * f10;
                            f5 = f5 * f11;
                            f0 = f0 + f2;
                            f2 = f3 * f12;
                            f3 = f7 * f10;
                            f7 = f8 * f11;
                            f4 = f4 + f5;
                            f5 = f6 * f12;
                            f0 = f0 + f2;
                            f2 = heapClassInst.heapFloat[r4 + numDefine12];
                            f6 = heapClassInst.heapFloat[r4 + numDefine13];
                            f8 = heapClassInst.heapFloat[r4 + numDefine14];
                            f4 = f4 + f5;
                            f3 = f3 + f7;
                            f5 = f9 * f12;
                            f0 = f0 + f2;
                            f2 = f3 + f5;
                            f3 = f4 + f6;
                            heapClassInst.heapFloat[r11 + numDefine12] = f0;
                            f0 = f2 + f8;
                            heapClassInst.heapFloat[r11 + numDefine13] = f3;
                            heapClassInst.heapFloat[r11 + numDefine14] = f0;
                            heapClassInst.heap32[r11 + numDefine15] = 0;
                            r11 = heapClassInst.heap32[r1];
                            r11 = r11 >> numDefine2;
                            r11 = heapClassInst.heap32[r11 + numDefine4];
                            heapClassInst.heap32[g0] = r0;
                            functionTable.get(r11 >> numDefine2).accept(i7);
                            r12 = commonVariable.rg0 >> numDefine2;
                            r12 = heapClassInst.heap32[r12];
                            r12 = r12 >> numDefine2;
                            r12 = heapClassInst.heap32[r12 + numDefine4];
                            r3 = (r3 + 1) | 0;
                            heapClassInst.heap32[g0] = commonVariable.rg0;
                            heapClassInst.heapFloat[g0 + 1] = f1;
                            heapClassInst.heap32[g0 + numDefine2] = r7;
                            heapClassInst.heap32[g0 + numDefine3] = r6;
                            r3 = r3 % numDefine3 | 0;
                            functionTable.get(r12 >> numDefine2).accept(i7);
                            r3 = r3 << numDefine2;
                            r7 = (r2 + r3) | 0;
                            f0 = heapClassInst.heapFloat[r4 + numDefine12];
                            f2 = heapClassInst.heapFloat[r4 + numDefine13];
                            f3 = heapClassInst.heapFloat[r4 + numDefine14];
                            r3 = (r10 + r3) | 0;
                            r7 = r7 >> numDefine2;
                            heapClassInst.heapFloat[r7] = f1;
                            r3 = r3 >> numDefine2;
                            heapClassInst.heapFloat[r3] = f1;
                            r11 = heapClassInst.heap32[r1];
                            r11 = r11 >> numDefine2;
                            r11 = heapClassInst.heap32[r11 + numDefine4];
                            heapClassInst.heap32[g0] = r0;
                            functionTable.get(r11 >> numDefine2).accept(i7);
                            r12 = commonVariable.rg0 >> numDefine2;
                            f4 = heapClassInst.heapFloat[fp + numDefineNeg184];
                            f5 = heapClassInst.heapFloat[r4];
                            f6 = heapClassInst.heapFloat[r9 + 1];
                            f7 = heapClassInst.heapFloat[r4 + 1];
                            r12 = heapClassInst.heap32[r12];
                            f8 = heapClassInst.heapFloat[r4 + numDefine4];
                            f9 = heapClassInst.heapFloat[r4 + numDefine5];
                            f10 = f5 * f4;
                            f11 = f7 * f6;
                            f12 = heapClassInst.heapFloat[r9 + numDefine2];
                            f13 = heapClassInst.heapFloat[r4 + numDefine2];
                            r12 = r12 >> numDefine2;
                            f14 = heapClassInst.heapFloat[r4 + numDefine8];
                            f15 = heapClassInst.heapFloat[r4 + numDefine9];
                            f16 = heapClassInst.heapFloat[r4 + numDefine6];
                            f17 = f8 * f4;
                            f18 = f9 * f6;
                            f10 = f10 + f11;
                            f11 = f13 * f12;
                            f10 = f10 + f11;
                            f11 = heapClassInst.heapFloat[r4 + numDefine10];
                            r12 = heapClassInst.heap32[r12 + numDefine2];
                            f4 = f14 * f4;
                            f6 = f15 * f6;
                            f17 = f17 + f18;
                            f18 = f16 * f12;
                            r13 = sp + numDefineNeg544;
                            f17 = f17 + f18;
                            f4 = f4 + f6;
                            f6 = f11 * f12;
                            f10 = f0 + f10;
                            f4 = f4 + f6;
                            r14 = r13 >> numDefine2;
                            f6 = f2 + f17;
                            heapClassInst.heapFloat[fp + numDefineNeg136] = f10;
                            f4 = f3 + f4;
                            heapClassInst.heapFloat[r14 + 1] = f6;
                            heapClassInst.heapFloat[r14 + numDefine2] = f4;
                            heapClassInst.heap32[r14 + numDefine3] = 0;
                            f4 = heapClassInst.heapFloat[fp + numDefineNeg180];
                            f6 = heapClassInst.heapFloat[r8 + 1];
                            f10 = heapClassInst.heapFloat[r8 + numDefine2];
                            f5 = f5 * f4;
                            f7 = f7 * f6;
                            f8 = f8 * f4;
                            f9 = f9 * f6;
                            f5 = f5 + f7;
                            f7 = f13 * f10;
                            f5 = f5 + f7;
                            f4 = f14 * f4;
                            f6 = f15 * f6;
                            f7 = f8 + f9;
                            f8 = f16 * f10;
                            r14 = sp + numDefineNeg528;
                            f7 = f7 + f8;
                            f4 = f4 + f6;
                            f6 = f11 * f10;
                            f5 = f0 + f5;
                            f4 = f4 + f6;
                            r15 = r14 >> numDefine2;
                            f6 = f2 + f7;
                            heapClassInst.heapFloat[fp + numDefineNeg132] = f5;
                            f4 = f3 + f4;
                            heapClassInst.heapFloat[r15 + 1] = f6;
                            heapClassInst.heapFloat[r15 + numDefine2] = f4;
                            heapClassInst.heap32[r15 + numDefine3] = 0;
                            heapClassInst.heap32[g0] = commonVariable.rg0;
                            heapClassInst.heap32[g0 + 1] = r14;
                            heapClassInst.heap32[g0 + numDefine2] = r13;
                            heapClassInst.heap32[g0 + numDefine3] = r6;
                            functionTable.get(r12 >> numDefine2).accept(i7);
                            f4 = -f1;
                            heapClassInst.heapFloat[r7] = f4;
                            heapClassInst.heapFloat[r3] = f4;
                            r11 = heapClassInst.heap32[r1];
                            r11 = r11 >> numDefine2;
                            r11 = heapClassInst.heap32[r11 + numDefine4];
                            heapClassInst.heap32[g0] = r0;
                            functionTable.get(r11 >> numDefine2).accept(i7);
                            r12 = commonVariable.rg0 >> numDefine2;
                            f5 = heapClassInst.heapFloat[fp + numDefineNeg184];
                            f6 = heapClassInst.heapFloat[r4];
                            f7 = heapClassInst.heapFloat[r9 + 1];
                            f8 = heapClassInst.heapFloat[r4 + 1];
                            r12 = heapClassInst.heap32[r12];
                            f9 = heapClassInst.heapFloat[r4 + numDefine4];
                            f10 = heapClassInst.heapFloat[r4 + numDefine5];
                            f11 = f6 * f5;
                            f12 = f8 * f7;
                            f13 = heapClassInst.heapFloat[r9 + numDefine2];
                            f14 = heapClassInst.heapFloat[r4 + numDefine2];
                            r12 = r12 >> numDefine2;
                            f15 = heapClassInst.heapFloat[r4 + numDefine8];
                            f16 = heapClassInst.heapFloat[r4 + numDefine9];
                            f17 = heapClassInst.heapFloat[r4 + numDefine6];
                            f18 = f9 * f5;
                            f19 = f10 * f7;
                            f11 = f11 + f12;
                            f12 = f14 * f13;
                            f11 = f11 + f12;
                            f12 = heapClassInst.heapFloat[r4 + numDefine10];
                            r12 = heapClassInst.heap32[r12 + numDefine2];
                            f5 = f15 * f5;
                            f7 = f16 * f7;
                            f18 = f18 + f19;
                            f19 = f17 * f13;
                            r13 = sp + numDefineNeg512;
                            f18 = f18 + f19;
                            f5 = f5 + f7;
                            f7 = f12 * f13;
                            f11 = f0 + f11;
                            f5 = f5 + f7;
                            r14 = r13 >> numDefine2;
                            f7 = f2 + f18;
                            heapClassInst.heapFloat[fp + numDefineNeg128] = f11;
                            f5 = f3 + f5;
                            heapClassInst.heapFloat[r14 + 1] = f7;
                            heapClassInst.heapFloat[r14 + numDefine2] = f5;
                            heapClassInst.heap32[r14 + numDefine3] = 0;
                            f5 = heapClassInst.heapFloat[fp + numDefineNeg180];
                            f7 = heapClassInst.heapFloat[r8 + 1];
                            f11 = heapClassInst.heapFloat[r8 + numDefine2];
                            f6 = f6 * f5;
                            f8 = f8 * f7;
                            f9 = f9 * f5;
                            f10 = f10 * f7;
                            f6 = f6 + f8;
                            f8 = f14 * f11;
                            f6 = f6 + f8;
                            f5 = f15 * f5;
                            f7 = f16 * f7;
                            f8 = f9 + f10;
                            f9 = f17 * f11;
                            r14 = sp + numDefineNeg496;
                            f8 = f8 + f9;
                            f5 = f5 + f7;
                            f7 = f12 * f11;
                            f6 = f0 + f6;
                            f5 = f5 + f7;
                            r15 = r14 >> numDefine2;
                            f7 = f2 + f8;
                            heapClassInst.heapFloat[fp + numDefineNeg124] = f6;
                            f5 = f3 + f5;
                            heapClassInst.heapFloat[r15 + 1] = f7;
                            heapClassInst.heapFloat[r15 + numDefine2] = f5;
                            heapClassInst.heap32[r15 + numDefine3] = 0;
                            heapClassInst.heap32[g0] = commonVariable.rg0;
                            heapClassInst.heap32[g0 + 1] = r14;
                            heapClassInst.heap32[g0 + numDefine2] = r13;
                            heapClassInst.heap32[g0 + numDefine3] = r6;
                            functionTable.get(r12 >> numDefine2).accept(i7);
                            heapClassInst.heap32[r7] = 0;
                            r2 = (r2 + r5) | 0;
                            r5 = (r10 + r5) | 0;
                            heapClassInst.heap32[r3] = 0;
                            r2 = r2 >> numDefine2;
                            heapClassInst.heapFloat[r2] = f1;
                            r3 = r5 >> numDefine2;
                            heapClassInst.heapFloat[r3] = f1;
                            r5 = heapClassInst.heap32[r1];
                            r5 = r5 >> numDefine2;
                            r5 = heapClassInst.heap32[r5 + numDefine4];
                            heapClassInst.heap32[g0] = r0;
                            functionTable.get(r5 >> numDefine2).accept(i7);
                            r7 = commonVariable.rg0 >> numDefine2;
                            f1 = heapClassInst.heapFloat[fp + numDefineNeg184];
                            f5 = heapClassInst.heapFloat[r4];
                            f6 = heapClassInst.heapFloat[r9 + 1];
                            f7 = heapClassInst.heapFloat[r4 + 1];
                            r7 = heapClassInst.heap32[r7];
                            f8 = heapClassInst.heapFloat[r4 + numDefine4];
                            f9 = heapClassInst.heapFloat[r4 + numDefine5];
                            f10 = f5 * f1;
                            f11 = f7 * f6;
                            f12 = heapClassInst.heapFloat[r9 + numDefine2];
                            f13 = heapClassInst.heapFloat[r4 + numDefine2];
                            r7 = r7 >> numDefine2;
                            f14 = heapClassInst.heapFloat[r4 + numDefine8];
                            f15 = heapClassInst.heapFloat[r4 + numDefine9];
                            f16 = heapClassInst.heapFloat[r4 + numDefine6];
                            f17 = f8 * f1;
                            f18 = f9 * f6;
                            f10 = f10 + f11;
                            f11 = f13 * f12;
                            f10 = f10 + f11;
                            f11 = heapClassInst.heapFloat[r4 + numDefine10];
                            r7 = heapClassInst.heap32[r7 + numDefine2];
                            f1 = f14 * f1;
                            f6 = f15 * f6;
                            f17 = f17 + f18;
                            f18 = f16 * f12;
                            r10 = sp + numDefineNeg480;
                            f17 = f17 + f18;
                            f1 = f1 + f6;
                            f6 = f11 * f12;
                            f10 = f0 + f10;
                            f1 = f1 + f6;
                            r11 = r10 >> numDefine2;
                            f6 = f2 + f17;
                            heapClassInst.heapFloat[fp + numDefineNeg120] = f10;
                            f1 = f3 + f1;
                            heapClassInst.heapFloat[r11 + 1] = f6;
                            heapClassInst.heapFloat[r11 + numDefine2] = f1;
                            heapClassInst.heap32[r11 + numDefine3] = 0;
                            f1 = heapClassInst.heapFloat[fp + numDefineNeg180];
                            f6 = heapClassInst.heapFloat[r8 + 1];
                            f10 = heapClassInst.heapFloat[r8 + numDefine2];
                            f5 = f5 * f1;
                            f7 = f7 * f6;
                            f8 = f8 * f1;
                            f9 = f9 * f6;
                            f5 = f5 + f7;
                            f7 = f13 * f10;
                            f5 = f5 + f7;
                            f1 = f14 * f1;
                            f6 = f15 * f6;
                            f7 = f8 + f9;
                            f8 = f16 * f10;
                            r11 = sp + numDefineNeg464;
                            f7 = f7 + f8;
                            f1 = f1 + f6;
                            f6 = f11 * f10;
                            f5 = f0 + f5;
                            f1 = f1 + f6;
                            r12 = r11 >> numDefine2;
                            f6 = f2 + f7;
                            heapClassInst.heapFloat[fp + numDefineNeg116] = f5;
                            f1 = f3 + f1;
                            heapClassInst.heapFloat[r12 + 1] = f6;
                            heapClassInst.heapFloat[r12 + numDefine2] = f1;
                            heapClassInst.heap32[r12 + numDefine3] = 0;
                            heapClassInst.heap32[g0] = commonVariable.rg0;
                            heapClassInst.heap32[g0 + 1] = r11;
                            heapClassInst.heap32[g0 + numDefine2] = r10;
                            heapClassInst.heap32[g0 + numDefine3] = r6;
                            functionTable.get(r7 >> numDefine2).accept(i7);
                            heapClassInst.heapFloat[r2] = f4;
                            heapClassInst.heapFloat[r3] = f4;
                            r1 = heapClassInst.heap32[r1];
                            r1 = r1 >> numDefine2;
                            r1 = heapClassInst.heap32[r1 + numDefine4];
                            heapClassInst.heap32[g0] = r0;
                            functionTable.get(r1 >> numDefine2).accept(i7);
                            r1 = commonVariable.rg0 >> numDefine2;
                            f1 = heapClassInst.heapFloat[fp + numDefineNeg184];
                            f4 = heapClassInst.heapFloat[r4];
                            f5 = heapClassInst.heapFloat[r9 + 1];
                            f6 = heapClassInst.heapFloat[r4 + 1];
                            r1 = heapClassInst.heap32[r1];
                            f7 = heapClassInst.heapFloat[r4 + numDefine4];
                            f8 = heapClassInst.heapFloat[r4 + numDefine5];
                            f9 = f4 * f1;
                            f10 = f6 * f5;
                            f11 = heapClassInst.heapFloat[r9 + numDefine2];
                            f12 = heapClassInst.heapFloat[r4 + numDefine2];
                            r1 = r1 >> numDefine2;
                            f13 = heapClassInst.heapFloat[r4 + numDefine8];
                            f14 = heapClassInst.heapFloat[r4 + numDefine9];
                            f15 = heapClassInst.heapFloat[r4 + numDefine6];
                            f16 = f7 * f1;
                            f17 = f8 * f5;
                            f9 = f9 + f10;
                            f10 = f12 * f11;
                            f9 = f9 + f10;
                            f10 = heapClassInst.heapFloat[r4 + numDefine10];
                            r1 = heapClassInst.heap32[r1 + numDefine2];
                            f1 = f13 * f1;
                            f5 = f14 * f5;
                            f16 = f16 + f17;
                            f17 = f15 * f11;
                            r2 = sp + numDefineNeg448;
                            f16 = f16 + f17;
                            f1 = f1 + f5;
                            f5 = f10 * f11;
                            f9 = f0 + f9;
                            f1 = f1 + f5;
                            r3 = r2 >> numDefine2;
                            f5 = f2 + f16;
                            heapClassInst.heapFloat[fp + numDefineNeg112] = f9;
                            f1 = f3 + f1;
                            heapClassInst.heapFloat[r3 + 1] = f5;
                            heapClassInst.heapFloat[r3 + numDefine2] = f1;
                            heapClassInst.heap32[r3 + numDefine3] = 0;
                            f1 = heapClassInst.heapFloat[fp + numDefineNeg180];
                            f5 = heapClassInst.heapFloat[r8 + 1];
                            f9 = heapClassInst.heapFloat[r8 + numDefine2];
                            f4 = f4 * f1;
                            f6 = f6 * f5;
                            f7 = f7 * f1;
                            f8 = f8 * f5;
                            f4 = f4 + f6;
                            f6 = f12 * f9;
                            f4 = f4 + f6;
                            f1 = f13 * f1;
                            f5 = f14 * f5;
                            f6 = f7 + f8;
                            f7 = f15 * f9;
                            r3 = sp + numDefineNeg432;
                            f6 = f6 + f7;
                            f1 = f1 + f5;
                            f5 = f10 * f9;
                            f0 = f0 + f4;
                            f1 = f1 + f5;
                            r4 = r3 >> numDefine2;
                            f2 = f2 + f6;
                            heapClassInst.heapFloat[fp + numDefineNeg108] = f0;
                            f0 = f3 + f1;
                            heapClassInst.heapFloat[r4 + 1] = f2;
                            heapClassInst.heapFloat[r4 + numDefine2] = f0;
                            heapClassInst.heap32[r4 + numDefine3] = 0;
                            heapClassInst.heap32[g0] = commonVariable.rg0;
                            heapClassInst.heap32[g0 + 1] = r3;
                            label = numDefine30;
                            break repeat1;
                        } else {
                            label = numDefine32;
                            break repeat1;
                        }
                    }
                } else {
                    if (r3 == 0) {
                        r3 = sp + numDefineNeg704;
                        f0 = heapClassInst.heapFloat[r5 + numDefine8];
                        f1 = heapClassInst.heapFloat[r5 + numDefine9];
                        f2 = heapClassInst.heapFloat[r5 + numDefine7];
                        r7 = r3 >> numDefine2;
                        heapClassInst.heap32[r7 + numDefine3] = heapClassInst.heap32[r5 + numDefine10];
                        r8 = heapClassInst.heap32[r5];
                        r8 = r8 >> numDefine2;
                        r8 = heapClassInst.heap32[r8 + numDefine11];
                        heapClassInst.heap32[g0] = r2;
                        functionTable.get(r8 >> numDefine2).accept(i7);
                        f3 = (float) commonVariable.fg0;
                        r8 = heapClassInst.heap32[r5];
                        r8 = r8 >> numDefine2;
                        r8 = heapClassInst.heap32[r8 + numDefine11];
                        heapClassInst.heap32[g0] = r2;
                        functionTable.get(r8 >> numDefine2).accept(i7);
                        f4 = (float) commonVariable.fg0;
                        r5 = heapClassInst.heap32[r5];
                        r5 = r5 >> numDefine2;
                        r5 = heapClassInst.heap32[r5 + numDefine11];
                        heapClassInst.heap32[g0] = r2;
                        functionTable.get(r5 >> numDefine2).accept(i7);
                        f2 = f2 + (float) commonVariable.fg0;
                        f0 = f0 + f4;
                        heapClassInst.heapFloat[fp + numDefineNeg176] = f2;
                        f1 = f1 + f3;
                        heapClassInst.heapFloat[r7 + 1] = f0;
                        heapClassInst.heapFloat[r7 + numDefine2] = f1;
                        r1 = heapClassInst.heap32[r1];
                        r1 = r1 >> numDefine2;
                        r1 = heapClassInst.heap32[r1 + numDefine4];
                        heapClassInst.heap32[g0] = r0;
                        functionTable.get(r1 >> numDefine2).accept(i7);
                        r1 = commonVariable.rg0 >> numDefine2;
                        r1 = heapClassInst.heap32[r1];
                        r1 = r1 >> numDefine2;
                        f0 = heapClassInst.heapFloat[r7 + numDefine2];
                        f1 = heapClassInst.heapFloat[r7 + 1];
                        f2 = heapClassInst.heapFloat[fp + numDefineNeg176];
                        r1 = heapClassInst.heap32[r1 + numDefine18];
                        r2 = sp + numDefineNeg624;
                        f2 = -f2;
                        r5 = r2 >> numDefine2;
                        f1 = -f1;
                        heapClassInst.heapFloat[fp + numDefineNeg156] = f2;
                        f0 = -f0;
                        heapClassInst.heapFloat[r5 + 1] = f1;
                        heapClassInst.heapFloat[r5 + numDefine2] = f0;
                        heapClassInst.heap32[r5 + numDefine3] = 0;
                        heapClassInst.heap32[g0] = commonVariable.rg0;
                        heapClassInst.heap32[g0 + 1] = r2;
                        heapClassInst.heap32[g0 + numDefine2] = r3;
                        heapClassInst.heap32[g0 + numDefine3] = r4;
                        heapClassInst.heap32[g0 + numDefine4] = r6;
                        functionTable.get(r1 >> numDefine2).accept(i7);
                        
                    } else {
                        if (r3 == numDefine8) {
                            r3 = heapClassInst.heap32[r5];
                            r3 = r3 >> numDefine2;
                            r3 = heapClassInst.heap32[r3 + numDefine11];
                            heapClassInst.heap32[g0] = r2;
                            functionTable.get(r3 >> numDefine2).accept(i7);
                            f0 = (float) commonVariable.fg0;
                            r1 = heapClassInst.heap32[r1];
                            r1 = r1 >> numDefine2;
                            r1 = heapClassInst.heap32[r1 + numDefine4];
                            heapClassInst.heap32[g0] = r0;
                            functionTable.get(r1 >> numDefine2).accept(i7);
                            r1 = commonVariable.rg0 >> numDefine2;
                            r1 = heapClassInst.heap32[r1];
                            r1 = r1 >> numDefine2;
                            r1 = heapClassInst.heap32[r1 + numDefine4];
                            heapClassInst.heap32[g0] = commonVariable.rg0;
                            heapClassInst.heapFloat[g0 + 1] = f0;
                            heapClassInst.heap32[g0 + numDefine2] = r4;
                            label = numDefine31;
                        } else {
                            label = numDefine32;
                        }
                    }
                }
            }
        } while (false);
        repeat41:
        do {
            switch (label) {
                case numDefine30:
                    heapClassInst.heap32[g0 + numDefine2] = r2;
                    label = numDefine31;
                    break repeat41;
                case numDefine32:
                    r7 = (r3 + numDefineNeg21) | 0;
                    if (uint(r7) < uint(numDefine9)) {
                        r3 = sp + numDefineNeg1024;
                        r7 = r3 >> numDefine2;
                        heapClassInst.heap32[fp + numDefineNeg256] = (int) numDefine44395;
                        heapClassInst.heap32[r7 + 1] = (int) numDefine44395;
                        heapClassInst.heap32[r7 + numDefine2] = (int) numDefine44395;
                        r8 = sp + numDefineNeg1040;
                        heapClassInst.heap32[r7 + numDefine3] = 0;
                        r7 = r8 >> numDefine2;
                        heapClassInst.heap32[fp + numDefineNeg260] = (int) numDefineNeg39253;
                        heapClassInst.heap32[r7 + 1] = (int) numDefineNeg39253;
                        heapClassInst.heap32[r7 + numDefine2] = (int) numDefineNeg39253;
                        heapClassInst.heap32[r7 + numDefine3] = 0;
                        r7 = heapClassInst.heap32[r1];
                        r7 = r7 >> numDefine2;
                        r7 = heapClassInst.heap32[r7 + numDefine4];
                        r9 = ztv17DebugDrawcallback;
                        heapClassInst.heap32[g0] = r0;
                        r10 = sp + numDefineNeg1136;
                        r11 = (r9 + numDefine8) | 0;
                        functionTable.get(r7 >> numDefine2).accept(i7);
                        r12 = r10 >> numDefine2;
                        r9 = (r9 + numDefine32) | 0;
                        heapClassInst.heap32[fp + numDefineNeg284] = r11;
                        heapClassInst.heap32[r12 + 1] = r9;
                        r13 = r6 >> numDefine2;
                        heapClassInst.heap32[r12 + numDefine2] = commonVariable.rg0;
                        heapClassInst.heap32[r12 + numDefine3] = heapClassInst.heap32[r13];
                        heapClassInst.heap32[r12 + numDefine4] = heapClassInst.heap32[r13 + 1];
                        heapClassInst.heap32[r12 + numDefine5] = heapClassInst.heap32[r13 + numDefine2];
                        r7 = r4 >> numDefine2;
                        heapClassInst.heap32[r12 + numDefine6] = heapClassInst.heap32[r13 + numDefine3];
                        heapClassInst.heap32[r12 + numDefine7] = heapClassInst.heap32[r7];
                        heapClassInst.heap32[r12 + numDefine8] = heapClassInst.heap32[r7 + 1];
                        heapClassInst.heap32[r12 + numDefine9] = heapClassInst.heap32[r7 + numDefine2];
                        heapClassInst.heap32[r12 + numDefine10] = heapClassInst.heap32[r7 + numDefine3];
                        heapClassInst.heap32[r12 + numDefine11] = heapClassInst.heap32[r7 + numDefine4];
                        heapClassInst.heap32[r12 + numDefine12] = heapClassInst.heap32[r7 + numDefine5];
                        heapClassInst.heap32[r12 + numDefine13] = heapClassInst.heap32[r7 + numDefine6];
                        heapClassInst.heap32[r12 + numDefine14] = heapClassInst.heap32[r7 + numDefine7];
                        heapClassInst.heap32[r12 + numDefine15] = heapClassInst.heap32[r7 + numDefine8];
                        heapClassInst.heap32[r12 + numDefine16] = heapClassInst.heap32[r7 + numDefine9];
                        heapClassInst.heap32[r12 + numDefine17] = heapClassInst.heap32[r7 + numDefine10];
                        heapClassInst.heap32[r12 + numDefine18] = heapClassInst.heap32[r7 + numDefine11];
                        heapClassInst.heap32[r12 + numDefine19] = heapClassInst.heap32[r7 + numDefine12];
                        heapClassInst.heap32[r12 + numDefine20] = heapClassInst.heap32[r7 + numDefine13];
                        heapClassInst.heap32[r12 + numDefine21] = heapClassInst.heap32[r7 + numDefine14];
                        heapClassInst.heap32[r12 + numDefine22] = heapClassInst.heap32[r7 + numDefine15];
                        r7 = heapClassInst.heap32[r5];
                        r7 = r7 >> numDefine2;
                        r7 = heapClassInst.heap32[r7 + numDefine15];
                        heapClassInst.heap32[g0] = r2;
                        heapClassInst.heap32[g0 + 1] = r10;
                        heapClassInst.heap32[g0 + numDefine2] = r8;
                        heapClassInst.heap32[g0 + numDefine3] = r3;
                        functionTable.get(r7 >> numDefine2).accept(i7);
                        r3 = r10 | numDefine4;
                        r7 = ztv31btInternalTriangleIndexCallback;
                        heapClassInst.heap32[fp + numDefineNeg284] = r11;
                        r8 = ztv18btTriangleCallback;
                        r3 = r3 >> numDefine2;
                        r7 = (r7 + numDefine8) | 0;
                        heapClassInst.heap32[r12 + 1] = r9;
                        r8 = (r8 + numDefine8) | 0;
                        heapClassInst.heap32[r3] = r7;
                        heapClassInst.heap32[fp + numDefineNeg284] = r8;
                        r3 = heapClassInst.heap32[r5 + 1];
                    }
                    if (r3 == numDefine3) {
                        r3 = sp + numDefineNeg1152;
                        r7 = r3 >> numDefine2;
                        heapClassInst.heap32[fp + numDefineNeg288] = numDefine44395;
                        heapClassInst.heap32[r7 + 1] = numDefine44395;
                        heapClassInst.heap32[r7 + numDefine2] = numDefine44395;
                        r8 = sp + numDefineNeg1168;
                        heapClassInst.heap32[r7 + numDefine3] = 0;
                        r7 = r8 >> numDefine2;
                        heapClassInst.heap32[fp + numDefineNeg292] = (int) numDefineNeg39253;
                        heapClassInst.heap32[r7 + 1] = (int) numDefineNeg39253;
                        heapClassInst.heap32[r7 + numDefine2] = (int) numDefineNeg39253;
                        heapClassInst.heap32[r7 + numDefine3] = 0;
                        r7 = heapClassInst.heap32[r1];
                        r7 = r7 >> numDefine2;
                        r7 = heapClassInst.heap32[r7 + numDefine4];
                        r9 = ztv17DebugDrawcallback;
                        heapClassInst.heap32[g0] = r0;
                        r10 = sp + numDefineNeg1264;
                        r11 = (r9 + numDefine8) | 0;
                        functionTable.get(r7 >> numDefine2).accept(i7);
                        r12 = r10 >> numDefine2;
                        r9 = (r9 + numDefine32) | 0;
                        heapClassInst.heap32[fp + numDefineNeg316] = r11;
                        heapClassInst.heap32[r12 + 1] = r9;
                        r13 = r6 >> numDefine2;
                        heapClassInst.heap32[r12 + numDefine2] = commonVariable.rg0;
                        heapClassInst.heap32[r12 + numDefine3] = heapClassInst.heap32[r13];
                        heapClassInst.heap32[r12 + numDefine4] = heapClassInst.heap32[r13 + 1];
                        heapClassInst.heap32[r12 + numDefine5] = heapClassInst.heap32[r13 + numDefine2];
                        r7 = r4 >> numDefine2;
                        heapClassInst.heap32[r12 + numDefine6] = heapClassInst.heap32[r13 + numDefine3];
                        heapClassInst.heap32[r12 + numDefine7] = heapClassInst.heap32[r7];
                        heapClassInst.heap32[r12 + numDefine8] = heapClassInst.heap32[r7 + 1];
                        heapClassInst.heap32[r12 + numDefine9] = heapClassInst.heap32[r7 + numDefine2];
                        heapClassInst.heap32[r12 + numDefine10] = heapClassInst.heap32[r7 + numDefine3];
                        heapClassInst.heap32[r12 + numDefine11] = heapClassInst.heap32[r7 + numDefine4];
                        heapClassInst.heap32[r12 + numDefine12] = heapClassInst.heap32[r7 + numDefine5];
                        heapClassInst.heap32[r12 + numDefine13] = heapClassInst.heap32[r7 + numDefine6];
                        heapClassInst.heap32[r12 + numDefine14] = heapClassInst.heap32[r7 + numDefine7];
                        heapClassInst.heap32[r12 + numDefine15] = heapClassInst.heap32[r7 + numDefine8];
                        heapClassInst.heap32[r12 + numDefine16] = heapClassInst.heap32[r7 + numDefine9];
                        heapClassInst.heap32[r12 + numDefine17] = heapClassInst.heap32[r7 + numDefine10];
                        heapClassInst.heap32[r12 + numDefine18] = heapClassInst.heap32[r7 + numDefine11];
                        heapClassInst.heap32[r12 + numDefine19] = heapClassInst.heap32[r7 + numDefine12];
                        heapClassInst.heap32[r12 + numDefine20] = heapClassInst.heap32[r7 + numDefine13];
                        heapClassInst.heap32[r12 + numDefine21] = heapClassInst.heap32[r7 + numDefine14];
                        heapClassInst.heap32[r12 + numDefine22] = heapClassInst.heap32[r7 + numDefine15];
                        r7 = heapClassInst.heap32[r5 + numDefine22];
                        r13 = r7 >> numDefine2;
                        r13 = heapClassInst.heap32[r13];
                        r13 = r13 >> numDefine2;
                        r13 = heapClassInst.heap32[r13 + numDefine2];
                        r14 = (r10 + numDefine4) | 0;
                        heapClassInst.heap32[g0] = r7;
                        heapClassInst.heap32[g0 + 1] = r14;
                        heapClassInst.heap32[g0 + numDefine2] = r8;
                        heapClassInst.heap32[g0 + numDefine3] = r3;
                        functionTable.get(r13 >> numDefine2).accept(i7);
                        r3 = r10 | numDefine4;
                        r7 = ztv31btInternalTriangleIndexCallback;
                        heapClassInst.heap32[fp + numDefineNeg316] = r11;
                        r8 = ztv18btTriangleCallback;
                        r3 = r3 >> numDefine2;
                        r7 = (r7 + numDefine8) | 0;
                        heapClassInst.heap32[r12 + 1] = r9;
                        r8 = (r8 + numDefine8) | 0;
                        heapClassInst.heap32[r3] = r7;
                        heapClassInst.heap32[fp + numDefineNeg316] = r8;
                        r3 = heapClassInst.heap32[r5 + 1];
                    }
                    if (r3 > numDefine6) {
                        label = numDefine40;
                    } else {
                        r3 = heapClassInst.heap32[r5];
                        r3 = r3 >> numDefine2;
                        r3 = heapClassInst.heap32[r3 + numDefine22];
                        heapClassInst.heap32[g0] = r2;
                        functionTable.get(r3 >> numDefine2).accept(i7);
                        r3 = commonVariable.rg0;
                        if (r3 < 1) {
                            label = numDefine40;
                        } else {
                            r3 = 0;
                            repeat52:
                            while (true) {
                                r7 = heapClassInst.heap32[r5];
                                r7 = r7 >> numDefine2;
                                r7 = heapClassInst.heap32[r7 + numDefine23];
                                r8 = sp + numDefineNeg1296;
                                r9 = sp + numDefineNeg1280;
                                heapClassInst.heap32[g0] = r2;
                                heapClassInst.heap32[g0 + 1] = r3;
                                heapClassInst.heap32[g0 + numDefine2] = r9;
                                heapClassInst.heap32[g0 + numDefine3] = r8;
                                functionTable.get(r7 >> numDefine2).accept(i7);
                                r7 = r4 >> numDefine2;
                                r9 = r9 >> numDefine2;
                                f0 = heapClassInst.heapFloat[fp + numDefineNeg320];
                                f1 = heapClassInst.heapFloat[r7];
                                f2 = heapClassInst.heapFloat[r9 + 1];
                                f3 = heapClassInst.heapFloat[r7 + 1];
                                f4 = heapClassInst.heapFloat[r7 + numDefine4];
                                f5 = heapClassInst.heapFloat[r7 + numDefine5];
                                f6 = f1 * f0;
                                f7 = f3 * f2;
                                f8 = heapClassInst.heapFloat[r9 + numDefine2];
                                f9 = heapClassInst.heapFloat[r7 + numDefine2];
                                f10 = heapClassInst.heapFloat[r7 + numDefine8];
                                f11 = heapClassInst.heapFloat[r7 + numDefine9];
                                f12 = heapClassInst.heapFloat[r7 + numDefine6];
                                f13 = f4 * f0;
                                f14 = f5 * f2;
                                f6 = f6 + f7;
                                f7 = f9 * f8;
                                f15 = heapClassInst.heapFloat[r7 + numDefine10];
                                f0 = f10 * f0;
                                f2 = f11 * f2;
                                f13 = f13 + f14;
                                f14 = f12 * f8;
                                f6 = f6 + f7;
                                f7 = heapClassInst.heapFloat[r7 + numDefine12];
                                f16 = heapClassInst.heapFloat[r7 + numDefine14];
                                f17 = heapClassInst.heapFloat[r7 + numDefine13];
                                r7 = sp + numDefineNeg1312;
                                f13 = f13 + f14;
                                f0 = f0 + f2;
                                f2 = f15 * f8;
                                f6 = f6 + f7;
                                f0 = f0 + f2;
                                r9 = r7 >> numDefine2;
                                f2 = f13 + f17;
                                heapClassInst.heapFloat[fp + numDefineNeg328] = f6;
                                f0 = f0 + f16;
                                heapClassInst.heapFloat[r9 + 1] = f2;
                                heapClassInst.heapFloat[r9 + numDefine2] = f0;
                                heapClassInst.heap32[r9 + numDefine3] = 0;
                                r8 = r8 >> numDefine2;
                                f0 = heapClassInst.heapFloat[fp + numDefineNeg324];
                                f2 = heapClassInst.heapFloat[r8 + 1];
                                f6 = heapClassInst.heapFloat[r8 + numDefine2];
                                f1 = f1 * f0;
                                f3 = f3 * f2;
                                f4 = f4 * f0;
                                f5 = f5 * f2;
                                f1 = f1 + f3;
                                f3 = f9 * f6;
                                f1 = f1 + f3;
                                f0 = f10 * f0;
                                f2 = f11 * f2;
                                f3 = f4 + f5;
                                f4 = f12 * f6;
                                r8 = sp + numDefineNeg1328;
                                f3 = f3 + f4;
                                f0 = f0 + f2;
                                f2 = f15 * f6;
                                f1 = f1 + f7;
                                f0 = f0 + f2;
                                r9 = r8 >> numDefine2;
                                f2 = f3 + f17;
                                heapClassInst.heapFloat[fp + numDefineNeg332] = f1;
                                f0 = f0 + f16;
                                heapClassInst.heapFloat[r9 + 1] = f2;
                                heapClassInst.heapFloat[r9 + numDefine2] = f0;
                                heapClassInst.heap32[r9 + numDefine3] = 0;
                                r9 = heapClassInst.heap32[r1];
                                r9 = r9 >> numDefine2;
                                r9 = heapClassInst.heap32[r9 + numDefine4];
                                heapClassInst.heap32[g0] = r0;
                                functionTable.get(r9 >> numDefine2).accept(i7);
                                r10 = commonVariable.rg0 >> numDefine2;
                                r10 = heapClassInst.heap32[r10];
                                r10 = r10 >> numDefine2;
                                r10 = heapClassInst.heap32[r10 + numDefine2];
                                heapClassInst.heap32[g0] = commonVariable.rg0;
                                heapClassInst.heap32[g0 + 1] = r7;
                                heapClassInst.heap32[g0 + numDefine2] = r8;
                                heapClassInst.heap32[g0 + numDefine3] = r6;
                                functionTable.get(r10 >> numDefine2).accept(i7);
                                r7 = heapClassInst.heap32[r5];
                                r7 = r7 >> numDefine2;
                                r7 = heapClassInst.heap32[r7 + numDefine22];
                                r3 = (r3 + 1) | 0;
                                heapClassInst.heap32[g0] = r2;
                                functionTable.get(r7 >> numDefine2).accept(i7);
                                r7 = commonVariable.rg0;
                                if (r7 > r3) {
                                    continue repeat52;
                                } else {
                                    label = numDefine40;
                                    break repeat41;
                                }
                            }
                        }
                    }
                    break;
                default:
                    break;
            }
        } while (false);
        switch (label) {
            case numDefine31:
                heapClassInst.heap32[g0 + numDefine3] = r6;
                functionTable.get(r1 >> numDefine2).accept(i7);
                
            case numDefine40:
                
            default:
                break;
        }
        
    }

    public static void znk16btCollisionWorld7rayTestERK9btVector3S2RNS17RayResultCallbackE(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        int r6 = 0;
        int r7 = 0;
        float f0 = 0.0F;
        float f1 = 0.0F;
        float f2 = 0.0F;
        float f3 = 0.0F;
        float f4 = 0.0F;
        float f5 = 0.0F;
        float f6 = 0.0F;
        float f7 = 0.0F;
        int label = 0;
        i7 = sp + numDefineNeg280;
        int g0 = i7 >> numDefine2;
        r0 = ztv19btSingleRayCallback;
        r1 = heapClassInst.heap32[fp + 1];
        r0 = (r0 + numDefine8) | 0;
        r2 = sp + numDefineNeg256;
        r3 = r1 >> numDefine2;
        heapClassInst.heap32[fp + numDefineNeg64] = r0;
        r0 = r2 >> numDefine2;
        f0 = heapClassInst.heapFloat[r3];
        heapClassInst.heapFloat[r0 + numDefine9] = f0;
        f1 = heapClassInst.heapFloat[r3 + 1];
        heapClassInst.heapFloat[r0 + numDefine10] = f1;
        f2 = heapClassInst.heapFloat[r3 + numDefine2];
        heapClassInst.heapFloat[r0 + numDefine11] = f2;
        r4 = heapClassInst.heap32[fp + numDefine2];
        f3 = heapClassInst.heapFloat[r3 + numDefine3];
        r3 = r4 >> numDefine2;
        heapClassInst.heapFloat[r0 + numDefine12] = f3;
        f4 = heapClassInst.heapFloat[r3];
        heapClassInst.heapFloat[r0 + numDefine13] = f4;
        f5 = heapClassInst.heapFloat[r3 + 1];
        heapClassInst.heapFloat[r0 + numDefine14] = f5;
        f6 = heapClassInst.heapFloat[r3 + numDefine2];
        heapClassInst.heapFloat[r0 + numDefine15] = f6;
        f7 = heapClassInst.heapFloat[r3 + numDefine3];
        r3 = heapClassInst.heap32[fp];
        heapClassInst.heapFloat[r0 + numDefine16] = f7;
        r5 = heapClassInst.heap32[fp + numDefine3];
        heapClassInst.heap32[r0 + numDefine53] = r3;
        heapClassInst.heap32[r0 + numDefine54] = r5;
        heapClassInst.heap32[r0 + numDefine17] = numDefine53216;
        heapClassInst.heap32[r0 + numDefine18] = 0;
        heapClassInst.heap32[r0 + numDefine19] = 0;
        heapClassInst.heap32[r0 + numDefine20] = 0;
        heapClassInst.heap32[r0 + numDefine21] = 0;
        heapClassInst.heap32[r0 + numDefine22] = numDefine53216;
        heapClassInst.heap32[r0 + numDefine23] = 0;
        heapClassInst.heap32[r0 + numDefine24] = 0;
        heapClassInst.heap32[r0 + numDefine25] = 0;
        heapClassInst.heap32[r0 + numDefine26] = 0;
        heapClassInst.heap32[r0 + numDefine27] = numDefine53216;
        heapClassInst.heap32[r0 + numDefine28] = 0;
        heapClassInst.heapFloat[r0 + numDefine29] = f0;
        heapClassInst.heapFloat[r0 + numDefine30] = f1;
        heapClassInst.heapFloat[r0 + numDefine31] = f2;
        heapClassInst.heapFloat[r0 + numDefine32] = f3;
        heapClassInst.heap32[r0 + numDefine33] = numDefine53216;
        heapClassInst.heap32[r0 + numDefine34] = 0;
        heapClassInst.heap32[r0 + numDefine35] = 0;
        heapClassInst.heap32[r0 + numDefine36] = 0;
        heapClassInst.heap32[r0 + numDefine37] = 0;
        heapClassInst.heap32[r0 + numDefine38] = numDefine53216;
        heapClassInst.heap32[r0 + numDefine39] = 0;
        heapClassInst.heap32[r0 + numDefine40] = 0;
        heapClassInst.heap32[r0 + numDefine41] = 0;
        heapClassInst.heap32[r0 + numDefine42] = 0;
        heapClassInst.heap32[r0 + numDefine43] = numDefine53216;
        heapClassInst.heap32[r0 + numDefine44] = 0;
        heapClassInst.heapFloat[r0 + numDefine45] = f4;
        f0 = f4 - f0;
        heapClassInst.heapFloat[r0 + numDefine46] = f5;
        f1 = f5 - f1;
        heapClassInst.heapFloat[r0 + numDefine47] = f6;
        f2 = f6 - f2;
        f3 = f0 * f0;
        f4 = f1 * f1;
        heapClassInst.heapFloat[r0 + numDefine48] = f7;
        f3 = f3 + f4;
        f4 = f2 * f2;
        f3 = f3 + f4;
        heapClassInst.heapFloat[g0] = f3;
        f3 = 1;
        sqrtf(i7);
        f4 = (float) (f3 / commonVariable.fg0);
        f0 = f0 * f4;
        f1 = f1 * f4;
        f2 = f2 * f4;
        f4 = 0;
        if (f0 != f4) {
            f5 = f3 / f0;
        } else {
            f5 = numDefine49440;
        }
        heapClassInst.heapFloat[r0 + 1] = f5;
        if (f1 != f4) {
            f6 = f3 / f1;
        } else {
            f6 = numDefine49440;
        }
        heapClassInst.heapFloat[r0 + numDefine2] = f6;
        if (f2 != f4) {
            f3 = f3 / f2;
        } else {
            f3 = numDefine49440;
        }

        r5 = f5 < f4 ? 1 : 0;

        r6 = f6 < f4 ? 1 : 0;
        r5 = r5 & 1;
        heapClassInst.heapFloat[r0 + numDefine3] = f3;

        r7 = f3 < f4 ? 1 : 0;
        r6 = r6 & 1;
        heapClassInst.heap32[r0 + numDefine5] = r5;
        r5 = r7 & 1;
        heapClassInst.heap32[r0 + numDefine6] = r6;
        heapClassInst.heap32[r0 + numDefine7] = r5;
        f3 = heapClassInst.heapFloat[r0 + numDefine14];
        f4 = heapClassInst.heapFloat[r0 + numDefine10];
        f5 = heapClassInst.heapFloat[r0 + numDefine13];
        f6 = heapClassInst.heapFloat[r0 + numDefine9];
        f5 = f5 - f6;
        f3 = f3 - f4;
        f4 = heapClassInst.heapFloat[r0 + numDefine15];
        f6 = heapClassInst.heapFloat[r0 + numDefine11];
        f0 = f0 * f5;
        f1 = f1 * f3;
        f3 = f4 - f6;
        f0 = f0 + f1;
        f1 = f2 * f3;
        f0 = f0 + f1;
        r3 = r3 >> numDefine2;
        heapClassInst.heapFloat[r0 + numDefine8] = f0;
        r0 = heapClassInst.heap32[r3 + numDefine20];
        r3 = r0 >> numDefine2;
        r3 = heapClassInst.heap32[r3];
        r3 = r3 >> numDefine2;
        r3 = heapClassInst.heap32[r3 + numDefine6];
        r5 = sp + numDefineNeg32;
        r6 = r5 >> numDefine2;
        heapClassInst.heap32[fp + numDefineNeg8] = 0;
        heapClassInst.heap32[r6 + 1] = 0;
        heapClassInst.heap32[r6 + numDefine2] = 0;
        r7 = sp + numDefineNeg16;
        heapClassInst.heap32[r6 + numDefine3] = 0;
        r6 = r7 >> numDefine2;
        heapClassInst.heap32[fp + numDefineNeg4] = 0;
        heapClassInst.heap32[r6 + 1] = 0;
        heapClassInst.heap32[r6 + numDefine2] = 0;
        heapClassInst.heap32[r6 + numDefine3] = 0;
        heapClassInst.heap32[g0] = r0;
        heapClassInst.heap32[g0 + 1] = r1;
        heapClassInst.heap32[g0 + numDefine2] = r4;
        heapClassInst.heap32[g0 + numDefine3] = r2;
        heapClassInst.heap32[g0 + numDefine4] = r7;
        heapClassInst.heap32[g0 + numDefine5] = r5;
        functionTable.get(r3 >> numDefine2).accept(i7);
        
    }

    public static void zn16btCollisionWorld18addCollisionObjectEP17btCollisionObjectss(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        int r6 = 0;
        int r7 = 0;
        int r8 = 0;
        int r9 = 0;
        int r10 = 0;
        int r11 = 0;
        int r12 = 0;
        int label = 0;
        i7 = sp + numDefineNeg136;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp + 1];
        if (r0 != 0) {
            r1 = heapClassInst.heap32[fp];
            r2 = heapClassInst.heap32[fp + numDefine2];
            r3 = heapClassInst.heap32[fp + numDefine3];
            r4 = r1 >> numDefine2;
            r5 = heapClassInst.heap32[r4 + numDefine2];
            r6 = 0;
            repeat3:
            while (true) {
                if (r5 > r6) {
                    r7 = heapClassInst.heap32[r4 + numDefine4];
                    r8 = r6 << numDefine2;
                    r7 = (r7 + r8) | 0;
                    r7 = r7 >> numDefine2;
                    r7 = heapClassInst.heap32[r7];
                    if (r7 == r0) {
                        label = numDefine6;
                        break repeat3;
                    } else {
                        r6 = (r6 + 1) | 0;
                    }
                } else {
                    label = numDefine8;
                    break repeat3;
                }
            }
            if (label == numDefine6) {
                if (!(r5 == r6)) {
                    r0 = twoEStr988;
                    r1 = twoEStr887;
                    heapClassInst.heap32[g0] = r0;
                    heapClassInst.heap32[g0 + 1] = r1;
                    heapClassInst.heap32[g0 + numDefine2] = numDefine114;
                    assertNew(i7);
                }
            }
            r6 = heapClassInst.heap32[r4 + numDefine3];
            if (r6 == r5) {
                r7 = 1;
                r8 = r5 << 1;
                r8 = r5 == 0 ? r7 : r8;
                if (!(r6 >= r8)) {
                    if (r8 != 0) {
                        r6 = gNumAlignedAllocs;
                        r6 = r6 >> numDefine2;
                        r9 = heapClassInst.heap32[r6];
                        r10 = r8 << numDefine2;
                        r9 = (r9 + 1) | 0;
                        r10 = r10 | numDefine3;
                        heapClassInst.heap32[r6] = r9;
                        r6 = (r10 + numDefine16) | 0;
                        heapClassInst.heap32[g0] = r6;
                        mallocNew(i7);
                        r6 = commonVariable.rg0;
                        if (r6 != 0) {
                            r9 = 0;
                            r10 = (r6 + numDefine4) | 0;
                            r9 = (r9 - r10) | 0;
                            r9 = r9 & numDefine15;
                            r9 = (r6 + r9) | 0;
                            r10 = (r9 + numDefine4) | 0;
                            r9 = r9 >> numDefine2;
                            heapClassInst.heap32[r9] = r6;
                            r6 = r10;
                        }
                    } else {
                        r6 = 0;
                    }
                    repeat19:
                    do {
                        if (r5 < 1) {
                            r10 = heapClassInst.heap32[r4 + numDefine4];
                        } else {
                            r9 = 0;
                            while (true) {
                                r10 = heapClassInst.heap32[r4 + numDefine4];
                                r11 = r9 << numDefine2;
                                r12 = (r10 + r11) | 0;
                                r12 = r12 >> numDefine2;
                                r11 = (r6 + r11) | 0;
                                r12 = heapClassInst.heap32[r12];
                                r9 = (r9 + 1) | 0;
                                r11 = r11 >> numDefine2;
                                heapClassInst.heap32[r11] = r12;
                                if (!(r5 != r9)) {
                                    break repeat19;
                                }
                            }
                        }
                    } while (false);
                    if (r10 != 0) {
                        r9 = heapClassInst.heapU8[r1 + numDefine20];
                        if (r9 != 0) {
                            r5 = gNumAlignedFree;
                            r5 = r5 >> numDefine2;
                            r9 = heapClassInst.heap32[r5];
                            r9 = (r9 + 1) | 0;
                            r10 = r10 >> numDefine2;
                            heapClassInst.heap32[r5] = r9;
                            r5 = heapClassInst.heap32[r10 + -1];
                            heapClassInst.heap32[g0] = r5;
                            free(i7);
                            r5 = heapClassInst.heap32[r4 + numDefine2];
                        }
                        heapClassInst.heap32[r4 + numDefine4] = 0;
                    }
                    heapClassInst.heap8[r1 + numDefine20] = (byte) r7;
                    heapClassInst.heap32[r4 + numDefine4] = r6;
                    heapClassInst.heap32[r4 + numDefine3] = r8;
                }
            }
            r1 = r5 << numDefine2;
            r5 = heapClassInst.heap32[r4 + numDefine4];
            r1 = (r5 + r1) | 0;
            r1 = r1 >> numDefine2;
            heapClassInst.heap32[r1] = r0;
            r1 = heapClassInst.heap32[r4 + numDefine2];
            r1 = (r1 + 1) | 0;
            r5 = sp + numDefineNeg64;
            r6 = r0 >> numDefine2;
            heapClassInst.heap32[r4 + numDefine2] = r1;
            r1 = r5 >> numDefine2;
            heapClassInst.heap32[fp + numDefineNeg16] = heapClassInst.heap32[r6 + 1];
            heapClassInst.heap32[r1 + 1] = heapClassInst.heap32[r6 + numDefine2];
            heapClassInst.heap32[r1 + numDefine2] = heapClassInst.heap32[r6 + numDefine3];
            heapClassInst.heap32[r1 + numDefine3] = heapClassInst.heap32[r6 + numDefine4];
            heapClassInst.heap32[r1 + numDefine4] = heapClassInst.heap32[r6 + numDefine5];
            heapClassInst.heap32[r1 + numDefine5] = heapClassInst.heap32[r6 + numDefine6];
            heapClassInst.heap32[r1 + numDefine6] = heapClassInst.heap32[r6 + numDefine7];
            heapClassInst.heap32[r1 + numDefine7] = heapClassInst.heap32[r6 + numDefine8];
            heapClassInst.heap32[r1 + numDefine8] = heapClassInst.heap32[r6 + numDefine9];
            heapClassInst.heap32[r1 + numDefine9] = heapClassInst.heap32[r6 + numDefine10];
            heapClassInst.heap32[r1 + numDefine10] = heapClassInst.heap32[r6 + numDefine11];
            heapClassInst.heap32[r1 + numDefine11] = heapClassInst.heap32[r6 + numDefine12];
            heapClassInst.heap32[r1 + numDefine12] = heapClassInst.heap32[r6 + numDefine13];
            heapClassInst.heap32[r1 + numDefine13] = heapClassInst.heap32[r6 + numDefine14];
            heapClassInst.heap32[r1 + numDefine14] = heapClassInst.heap32[r6 + numDefine15];
            heapClassInst.heap32[r1 + numDefine15] = heapClassInst.heap32[r6 + numDefine16];
            r1 = heapClassInst.heap32[r6 + numDefine48];
            r7 = r1 >> numDefine2;
            r7 = heapClassInst.heap32[r7];
            r7 = r7 >> numDefine2;
            r7 = heapClassInst.heap32[r7 + numDefine2];
            r8 = sp + numDefineNeg80;
            r9 = sp + numDefineNeg96;
            heapClassInst.heap32[g0] = r1;
            heapClassInst.heap32[g0 + 1] = r5;
            heapClassInst.heap32[g0 + numDefine2] = r8;
            heapClassInst.heap32[g0 + numDefine3] = r9;
            functionTable.get(r7 >> numDefine2).accept(i7);
            r1 = heapClassInst.heap32[r4 + numDefine20];
            r5 = r1 >> numDefine2;
            r7 = heapClassInst.heap32[r6 + numDefine48];
            r5 = heapClassInst.heap32[r5];
            r5 = r5 >> numDefine2;
            r7 = r7 >> numDefine2;
            r5 = heapClassInst.heap32[r5 + numDefine2];
            r7 = heapClassInst.heap32[r7 + 1];
            r4 = heapClassInst.heap32[r4 + numDefine6];
            heapClassInst.heap32[g0] = r1;
            heapClassInst.heap32[g0 + 1] = r8;
            heapClassInst.heap32[g0 + numDefine2] = r9;
            heapClassInst.heap32[g0 + numDefine3] = r7;
            heapClassInst.heap32[g0 + numDefine4] = r0;
            heapClassInst.heap32[g0 + numDefine5] = r2;
            heapClassInst.heap32[g0 + numDefine6] = r3;
            heapClassInst.heap32[g0 + numDefine7] = r4;
            heapClassInst.heap32[g0 + numDefine8] = 0;
            functionTable.get(r5 >> numDefine2).accept(i7);
            heapClassInst.heap32[r6 + numDefine47] = commonVariable.rg0;
            
        } else {
            r0 = twoEStr786;
            r1 = twoEStr887;
            heapClassInst.heap32[g0] = r0;
            heapClassInst.heap32[g0 + 1] = r1;
            heapClassInst.heap32[g0 + numDefine2] = numDefine111;
            assertNew(i7);
        }
        
    }

    public static void zn16btCollisionWorld21removeCollisionObjectEP17btCollisionObject(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        int r6 = 0;
        int r7 = 0;
        int label = 0;
        i7 = sp + numDefineNeg16;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp + 1];
        r1 = r0 >> numDefine2;
        r2 = heapClassInst.heap32[r1 + numDefine47];
        r3 = heapClassInst.heap32[fp];
        if (!(r2 == 0)) {
            r4 = r3 >> numDefine2;
            r5 = heapClassInst.heap32[r4 + numDefine20];
            r6 = r5 >> numDefine2;
            r6 = heapClassInst.heap32[r6];
            r6 = r6 >> numDefine2;
            r6 = heapClassInst.heap32[r6 + numDefine9];
            heapClassInst.heap32[g0] = r5;
            functionTable.get(r6 >> numDefine2).accept(i7);
            r6 = commonVariable.rg0 >> numDefine2;
            r6 = heapClassInst.heap32[r6];
            r6 = r6 >> numDefine2;
            r6 = heapClassInst.heap32[r6 + numDefine10];
            r7 = heapClassInst.heap32[r4 + numDefine6];
            heapClassInst.heap32[g0] = commonVariable.rg0;
            heapClassInst.heap32[g0 + 1] = r2;
            heapClassInst.heap32[g0 + numDefine2] = r7;
            functionTable.get(r6 >> numDefine2).accept(i7);
            r5 = heapClassInst.heap32[r4 + numDefine20];
            r6 = r5 >> numDefine2;
            r6 = heapClassInst.heap32[r6];
            r6 = r6 >> numDefine2;
            r6 = heapClassInst.heap32[r6 + numDefine3];
            r4 = heapClassInst.heap32[r4 + numDefine6];
            heapClassInst.heap32[g0] = r5;
            heapClassInst.heap32[g0 + 1] = r2;
            heapClassInst.heap32[g0 + numDefine2] = r4;
            functionTable.get(r6 >> numDefine2).accept(i7);
            heapClassInst.heap32[r1 + numDefine47] = 0;
        }
        r1 = r3 >> numDefine2;
        r2 = heapClassInst.heap32[r1 + numDefine2];
        r3 = 0;
        repeat4:
        while (true) {
            if (r2 > r3) {
                r4 = heapClassInst.heap32[r1 + numDefine4];
                r5 = r3 << numDefine2;
                r4 = (r4 + r5) | 0;
                r4 = r4 >> numDefine2;
                r4 = heapClassInst.heap32[r4];
                if (r4 != r0) {
                    r3 = (r3 + 1) | 0;
                    continue repeat4;
                } else {
                    label = numDefine7;
                    break repeat4;
                }
            } else {
                label = numDefine6;
                break repeat4;
            }
        }
        if (label == numDefine6) {
            r3 = r2;
        }
        if (!(r2 <= r3)) {
            r0 = (r2 + -1) | 0;
            r2 = r3 << numDefine2;
            r3 = heapClassInst.heap32[r1 + numDefine4];
            r0 = r0 << numDefine2;
            r2 = (r3 + r2) | 0;
            r3 = (r3 + r0) | 0;
            r2 = r2 >> numDefine2;
            r3 = r3 >> numDefine2;
            r4 = heapClassInst.heap32[r2];
            r3 = heapClassInst.heap32[r3];
            heapClassInst.heap32[r2] = r3;
            r2 = heapClassInst.heap32[r1 + numDefine4];
            r0 = (r2 + r0) | 0;
            r0 = r0 >> numDefine2;
            heapClassInst.heap32[r0] = r4;
            r0 = heapClassInst.heap32[r1 + numDefine2];
            r0 = (r0 + -1) | 0;
            heapClassInst.heap32[r1 + numDefine2] = r0;
        }
        
    }

    public static void zn16btCollisionWorld33performDiscreteCollisionDetectionEv(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        int r6 = 0;
        int r7 = 0;
        float f0 = 0.0F;
        float f1 = 0.0F;
        float f2 = 0.0F;
        int label = 0;
        i7 = sp + numDefineNeg40;
        int g0 = i7 >> numDefine2;
        r0 = twoEStr1190;
        r1 = heapClassInst.heap32[fp];
        heapClassInst.heap32[g0] = r0;
        zn15CProfileManager13StartProfileEPKc(i7);
        r0 = r1 >> numDefine2;
        r2 = heapClassInst.heap32[r0];
        r2 = r2 >> numDefine2;
        r2 = heapClassInst.heap32[r2 + numDefine2];
        heapClassInst.heap32[g0] = r1;
        functionTable.get(r2 >> numDefine2).accept(i7);
        r2 = twoEStr1291;
        heapClassInst.heap32[g0] = r2;
        zn15CProfileManager13StartProfileEPKc(i7);
        r2 = heapClassInst.heap32[r0 + numDefine20];
        r3 = r2 >> numDefine2;
        r3 = heapClassInst.heap32[r3];
        r3 = r3 >> numDefine2;
        r3 = heapClassInst.heap32[r3 + numDefine8];
        r4 = heapClassInst.heap32[r0 + numDefine6];
        heapClassInst.heap32[g0] = r2;
        heapClassInst.heap32[g0 + 1] = r4;
        r2 = zn15CProfileManager11CurrentNodeE;
        functionTable.get(r3 >> numDefine2).accept(i7);
        r2 = r2 >> numDefine2;
        r3 = heapClassInst.heap32[r2];
        r4 = r3 >> numDefine2;
        r5 = heapClassInst.heap32[r4 + numDefine4];
        r5 = (r5 + -1) | 0;
        heapClassInst.heap32[r4 + numDefine4] = r5;
        repeat1:
        do {
            if (!(r5 != 0)) {
                r5 = heapClassInst.heap32[r4 + 1];
                if (r5 != 0) {
                    r3 = sp + numDefineNeg24;
                    heapClassInst.heap32[g0] = r3;
                    heapClassInst.heap32[g0 + 1] = 0;
                    r5 = zl13gProfileClock2E0;
                    getTimeOfDay(i7);
                    r5 = r5 >> numDefine2;
                    r5 = heapClassInst.heap32[r5];
                    r5 = r5 >> numDefine2;
                    r3 = r3 >> numDefine2;
                    r6 = heapClassInst.heap32[fp + numDefineNeg6];
                    r7 = heapClassInst.heap32[r5];
                    r6 = (r6 - r7) | 0;
                    r3 = heapClassInst.heap32[r3 + 1];
                    r5 = heapClassInst.heap32[r5 + 1];
                    r3 = (r3 - r5) | 0;
                    r5 = (int) ((r6 * numDefineN6) | 0);
                    r3 = (r3 + r5) | 0;
                    r5 = heapClassInst.heap32[r4 + numDefine3];
                    r3 = (r3 - r5) | 0;
                    f0 = uint(r3);
                    f1 = numDefine1000;
                    f2 = heapClassInst.heapFloat[r4 + numDefine2];
                    f0 = f0 / f1;
                    f0 = f2 + f0;
                    heapClassInst.heapFloat[r4 + numDefine2] = f0;
                    r3 = heapClassInst.heap32[r4 + numDefine4];
                    if (r3 != 0) {
                        break repeat1;
                    } else {
                        r3 = heapClassInst.heap32[r2];
                    }
                }
                r3 = r3 >> numDefine2;
                r3 = heapClassInst.heap32[r3 + numDefine5];
                heapClassInst.heap32[r2] = r3;
            }
        } while (false);
        r3 = heapClassInst.heap32[r0 + numDefine6];
        r4 = twoEStr1392;
        heapClassInst.heap32[g0] = r4;
        zn15CProfileManager13StartProfileEPKc(i7);
        if (!(r3 == 0)) {
            r4 = heapClassInst.heap32[r0 + numDefine20];
            r5 = r3 >> numDefine2;
            r6 = r4 >> numDefine2;
            r5 = heapClassInst.heap32[r5];
            r6 = heapClassInst.heap32[r6];
            r5 = r5 >> numDefine2;
            r6 = r6 >> numDefine2;
            r5 = heapClassInst.heap32[r5 + numDefine8];
            r0 = heapClassInst.heap32[r0 + numDefine6];
            r6 = heapClassInst.heap32[r6 + numDefine9];
            heapClassInst.heap32[g0] = r4;
            functionTable.get(r6 >> numDefine2).accept(i7);
            r1 = (r1 + numDefine28) | 0;
            heapClassInst.heap32[g0] = r3;
            heapClassInst.heap32[g0 + 1] = commonVariable.rg0;
            heapClassInst.heap32[g0 + numDefine2] = r1;
            heapClassInst.heap32[g0 + numDefine3] = r0;
            functionTable.get(r5 >> numDefine2).accept(i7);
        }
        r0 = heapClassInst.heap32[r2];
        r1 = r0 >> numDefine2;
        r3 = heapClassInst.heap32[r1 + numDefine4];
        r3 = (r3 + -1) | 0;
        heapClassInst.heap32[r1 + numDefine4] = r3;
        repeat11:
        do {
            if (r3 == 0) {
                r3 = heapClassInst.heap32[r1 + 1];
                if (r3 != 0) {
                    r0 = sp + numDefineNeg16;
                    heapClassInst.heap32[g0] = r0;
                    heapClassInst.heap32[g0 + 1] = 0;
                    r3 = zl13gProfileClock2E0;
                    getTimeOfDay(i7);
                    r3 = r3 >> numDefine2;
                    r3 = heapClassInst.heap32[r3];
                    r3 = r3 >> numDefine2;
                    r0 = r0 >> numDefine2;
                    r4 = heapClassInst.heap32[fp + numDefineNeg4];
                    r5 = heapClassInst.heap32[r3];
                    r4 = (r4 - r5) | 0;
                    r0 = heapClassInst.heap32[r0 + 1];
                    r3 = heapClassInst.heap32[r3 + 1];
                    r0 = (r0 - r3) | 0;
                    r3 = (int) ((r4 * numDefineN6) | 0);
                    r0 = (r0 + r3) | 0;
                    r3 = heapClassInst.heap32[r1 + numDefine3];
                    r0 = (r0 - r3) | 0;
                    f0 = uint(r0);
                    f1 = numDefine1000;
                    f2 = heapClassInst.heapFloat[r1 + numDefine2];
                    f0 = f0 / f1;
                    f0 = f2 + f0;
                    heapClassInst.heapFloat[r1 + numDefine2] = f0;
                    r0 = heapClassInst.heap32[r2];
                    r1 = heapClassInst.heap32[r1 + numDefine4];
                    if (!(r1 == 0)) {
                        break repeat11;
                    }
                }
                r0 = r0 >> numDefine2;
                r0 = heapClassInst.heap32[r0 + numDefine5];
                heapClassInst.heap32[r2] = r0;
            }
        } while (false);
        r1 = r0 >> numDefine2;
        r3 = heapClassInst.heap32[r1 + numDefine4];
        r3 = (r3 + -1) | 0;
        heapClassInst.heap32[r1 + numDefine4] = r3;
        repeat17:
        do {
            if (!(r3 != 0)) {
                r3 = heapClassInst.heap32[r1 + 1];
                if (r3 != 0) {
                    r0 = sp + numDefineNeg8;
                    heapClassInst.heap32[g0] = r0;
                    heapClassInst.heap32[g0 + 1] = 0;
                    r3 = zl13gProfileClock2E0;
                    getTimeOfDay(i7);
                    r3 = r3 >> numDefine2;
                    r3 = heapClassInst.heap32[r3];
                    r3 = r3 >> numDefine2;
                    r0 = r0 >> numDefine2;
                    r4 = heapClassInst.heap32[fp + numDefineNeg2];
                    r5 = heapClassInst.heap32[r3];
                    r4 = (r4 - r5) | 0;
                    r0 = heapClassInst.heap32[r0 + 1];
                    r3 = heapClassInst.heap32[r3 + 1];
                    r0 = (r0 - r3) | 0;
                    r3 = (int) ((r4 * numDefineN6) | 0);
                    r0 = (r0 + r3) | 0;
                    r3 = heapClassInst.heap32[r1 + numDefine3];
                    r0 = (r0 - r3) | 0;
                    f0 = uint(r0);
                    f1 = numDefine1000;
                    f2 = heapClassInst.heapFloat[r1 + numDefine2];
                    f0 = f0 / f1;
                    f0 = f2 + f0;
                    heapClassInst.heapFloat[r1 + numDefine2] = f0;
                    r0 = heapClassInst.heap32[r1 + numDefine4];
                    if (r0 != 0) {
                        break repeat17;
                    } else {
                        r0 = heapClassInst.heap32[r2];
                    }
                }
                r0 = r0 >> numDefine2;
                r0 = heapClassInst.heap32[r0 + numDefine5];
                heapClassInst.heap32[r2] = r0;
            }
        } while (false);
        
    }

    public static void zn16btCollisionWorld9serializeEP12btSerializer(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int label = 0;
        i7 = sp + numDefineNeg8;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp + 1];
        r1 = r0 >> numDefine2;
        r2 = heapClassInst.heap32[r1];
        r2 = r2 >> numDefine2;
        r2 = heapClassInst.heap32[r2 + numDefine8];
        heapClassInst.heap32[g0] = r0;
        functionTable.get(r2 >> numDefine2).accept(i7);
        r2 = heapClassInst.heap32[fp];
        heapClassInst.heap32[g0] = r2;
        heapClassInst.heap32[g0 + 1] = r0;
        zn16btCollisionWorld25serializeCollisionObjectsEP12btSerializer(i7);
        r1 = heapClassInst.heap32[r1];
        r1 = r1 >> numDefine2;
        r1 = heapClassInst.heap32[r1 + numDefine9];
        heapClassInst.heap32[g0] = r0;
        functionTable.get(r1 >> numDefine2).accept(i7);
        
    }

    public static void zn21btSingleSweepCallbackD0Ev(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int label = 0;
        i7 = sp + numDefineNeg8;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = ztv21btSingleSweepCallback;
        r2 = r0 >> numDefine2;
        r1 = (r1 + numDefine8) | 0;
        heapClassInst.heap32[r2] = r1;
        heapClassInst.heap32[g0] = r0;
        zdlPv(i7);
        
    }

    public static void zn21btSingleSweepCallbackD1Ev(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int label = 0;
        i7 = sp + 0;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = ztv21btSingleSweepCallback;
        r0 = r0 >> numDefine2;
        r1 = (r1 + numDefine8) | 0;
        heapClassInst.heap32[r0] = r1;
        
    }

    public static void zn21btSingleSweepCallback7processEPK17btBroadphaseProxy(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        int r6 = 0;
        float f0 = 0.0F;
        float f1 = 0.0F;
        int label = 0;
        i7 = sp + numDefineNeg32;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = r0 >> numDefine2;
        r2 = heapClassInst.heap32[r1 + numDefine46];
        r3 = r2 >> numDefine2;
        f0 = heapClassInst.heapFloat[r3 + 1];
        f1 = 0;
        if (f0 != f1) {
            r4 = heapClassInst.heap32[fp + 1];
            r4 = r4 >> numDefine2;
            r4 = heapClassInst.heap32[r4];
            r3 = heapClassInst.heap32[r3];
            r3 = r3 >> numDefine2;
            r5 = r4 >> numDefine2;
            r3 = heapClassInst.heap32[r3 + numDefine2];
            r6 = heapClassInst.heap32[r5 + numDefine47];
            heapClassInst.heap32[g0] = r2;
            heapClassInst.heap32[g0 + 1] = r6;
            functionTable.get(r3 >> numDefine2).accept(i7);
            r2 = commonVariable.rg0;
            if (r2 != 0) {
                f0 = heapClassInst.heapFloat[r1 + numDefine47];
                r2 = heapClassInst.heap32[r1 + numDefine46];
                r3 = heapClassInst.heap32[r5 + numDefine48];
                r1 = heapClassInst.heap32[r1 + numDefine48];
                r5 = (r0 + numDefine36) | 0;
                r0 = (r0 + numDefine100) | 0;
                r6 = (r4 + numDefine4) | 0;
                heapClassInst.heap32[g0] = r1;
                heapClassInst.heap32[g0 + 1] = r5;
                heapClassInst.heap32[g0 + numDefine2] = r0;
                heapClassInst.heap32[g0 + numDefine3] = r4;
                heapClassInst.heap32[g0 + numDefine4] = r3;
                heapClassInst.heap32[g0 + numDefine5] = r6;
                heapClassInst.heap32[g0 + numDefine6] = r2;
                heapClassInst.heapFloat[g0 + numDefine7] = f0;
                zn16btCollisionWorld17objectQuerySingleEPK13btConvexShapeRK11btTransformS5P17btCollisionObjectPK16btCollisionShapeS5RNS20ConvexResultCallbackEf(i7);
                r0 = 1;
                commonVariable.rg0 = r0;
                
            } else {
                r0 = 1;
            }
        } else {
            r0 = 0;
        }
        r0 = r0 & numDefine255;
        commonVariable.rg0 = r0;
        
    }

    public static void zn19btSingleRayCallbackD0Ev(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int label = 0;
        i7 = sp + numDefineNeg8;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = ztv19btSingleRayCallback;
        r2 = r0 >> numDefine2;
        r1 = (r1 + numDefine8) | 0;
        heapClassInst.heap32[r2] = r1;
        heapClassInst.heap32[g0] = r0;
        zdlPv(i7);
        
    }

    public static void zn19btSingleRayCallbackD1Ev(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int label = 0;
        i7 = sp + 0;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = ztv19btSingleRayCallback;
        r0 = r0 >> numDefine2;
        r1 = (r1 + numDefine8) | 0;
        heapClassInst.heap32[r0] = r1;
        
    }

    public static void zn19btSingleRayCallback7processEPK17btBroadphaseProxy(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        int r6 = 0;
        float f0 = 0.0F;
        float f1 = 0.0F;
        int label = 0;
        i7 = sp + numDefineNeg24;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = r0 >> numDefine2;
        r2 = heapClassInst.heap32[r1 + numDefine54];
        r3 = r2 >> numDefine2;
        f0 = heapClassInst.heapFloat[r3 + 1];
        f1 = 0;
        if (f0 != f1) {
            r4 = heapClassInst.heap32[fp + 1];
            r4 = r4 >> numDefine2;
            r4 = heapClassInst.heap32[r4];
            r3 = heapClassInst.heap32[r3];
            r3 = r3 >> numDefine2;
            r5 = r4 >> numDefine2;
            r3 = heapClassInst.heap32[r3 + numDefine2];
            r6 = heapClassInst.heap32[r5 + numDefine47];
            heapClassInst.heap32[g0] = r2;
            heapClassInst.heap32[g0 + 1] = r6;
            functionTable.get(r3 >> numDefine2).accept(i7);
            r2 = commonVariable.rg0;
            if (r2 != 0) {
                r1 = heapClassInst.heap32[r1 + numDefine54];
                r2 = heapClassInst.heap32[r5 + numDefine48];
                r3 = (r0 + numDefine68) | 0;
                r0 = (r0 + numDefine132) | 0;
                r5 = (r4 + numDefine4) | 0;
                heapClassInst.heap32[g0] = r3;
                heapClassInst.heap32[g0 + 1] = r0;
                heapClassInst.heap32[g0 + numDefine2] = r4;
                heapClassInst.heap32[g0 + numDefine3] = r2;
                heapClassInst.heap32[g0 + numDefine4] = r5;
                heapClassInst.heap32[g0 + numDefine5] = r1;
                zn16btCollisionWorld13rayTestSingleERK11btTransformS2P17btCollisionObjectPK16btCollisionShapeS2RNS17RayResultCallbackE(i7);
                r0 = 1;
                commonVariable.rg0 = r0;
                
            } else {
                r0 = 1;
            }
        } else {
            r0 = 0;
        }
        r0 = r0 & numDefine255;
        commonVariable.rg0 = r0;
        
    }

    public static void zn16btCollisionWorldD2Ev(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        int r6 = 0;
        int r7 = 0;
        int label = 0;
        i7 = sp + numDefineNeg16;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = ztv16btCollisionWorld;
        r2 = r0 >> numDefine2;
        r1 = (r1 + numDefine8) | 0;
        heapClassInst.heap32[r2] = r1;
        r1 = heapClassInst.heap32[r2 + numDefine4];
        r3 = heapClassInst.heap32[r2 + numDefine2];
        if (r3 > 0) {
            r3 = 0;
            repeat3:
            while (true) {
                r4 = r3 << numDefine2;
                r1 = (r1 + r4) | 0;
                r1 = r1 >> numDefine2;
                r1 = heapClassInst.heap32[r1];
                r1 = r1 >> numDefine2;
                r4 = heapClassInst.heap32[r1 + numDefine47];
                if (!(r4 == 0)) {
                    r5 = heapClassInst.heap32[r2 + numDefine20];
                    r6 = r5 >> numDefine2;
                    r6 = heapClassInst.heap32[r6];
                    r6 = r6 >> numDefine2;
                    r6 = heapClassInst.heap32[r6 + numDefine9];
                    heapClassInst.heap32[g0] = r5;
                    functionTable.get(r6 >> numDefine2).accept(i7);
                    r6 = commonVariable.rg0 >> numDefine2;
                    r6 = heapClassInst.heap32[r6];
                    r6 = r6 >> numDefine2;
                    r6 = heapClassInst.heap32[r6 + numDefine10];
                    r7 = heapClassInst.heap32[r2 + numDefine6];
                    heapClassInst.heap32[g0] = commonVariable.rg0;
                    heapClassInst.heap32[g0 + 1] = r4;
                    heapClassInst.heap32[g0 + numDefine2] = r7;
                    functionTable.get(r6 >> numDefine2).accept(i7);
                    r5 = heapClassInst.heap32[r2 + numDefine20];
                    r6 = r5 >> numDefine2;
                    r6 = heapClassInst.heap32[r6];
                    r6 = r6 >> numDefine2;
                    r6 = heapClassInst.heap32[r6 + numDefine3];
                    r7 = heapClassInst.heap32[r2 + numDefine6];
                    heapClassInst.heap32[g0] = r5;
                    heapClassInst.heap32[g0 + 1] = r4;
                    heapClassInst.heap32[g0 + numDefine2] = r7;
                    functionTable.get(r6 >> numDefine2).accept(i7);
                    heapClassInst.heap32[r1 + numDefine47] = 0;
                }
                r3 = (r3 + 1) | 0;
                r1 = heapClassInst.heap32[r2 + numDefine4];
                r4 = heapClassInst.heap32[r2 + numDefine2];
                if (r4 > r3) {
                    continue repeat3;
                } else {
                    break repeat3;
                }
            }
        }
        if (!(r1 == 0)) {
            r3 = heapClassInst.heapU8[r0 + numDefine20];
            if (!(r3 == 0)) {
                r3 = gNumAlignedFree;
                r3 = r3 >> numDefine2;
                r4 = heapClassInst.heap32[r3];
                r4 = (r4 + 1) | 0;
                r1 = r1 >> numDefine2;
                heapClassInst.heap32[r3] = r4;
                r1 = heapClassInst.heap32[r1 + -1];
                heapClassInst.heap32[g0] = r1;
                free(i7);
            }
            heapClassInst.heap32[r2 + numDefine4] = 0;
        }
        r1 = 1;
        heapClassInst.heap8[r0 + numDefine20] = (byte) r1;
        heapClassInst.heap32[r2 + numDefine4] = 0;
        heapClassInst.heap32[r2 + numDefine2] = 0;
        heapClassInst.heap32[r2 + numDefine3] = 0;
        return;
    }

    public static void zn16btCollisionWorld25serializeCollisionObjectsEP12btSerializer(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        int r6 = 0;
        int r7 = 0;
        int r8 = 0;
        int r9 = 0;
        int r10 = 0;
        int r11 = 0;
        int r12 = 0;
        int r13 = 0;
        int r14 = 0;
        int r15 = 0;
        int r16 = 0;
        int r17 = 0;
        int r18 = 0;
        int r19 = 0;
        int r20 = 0;
        int r21 = 0;
        int r22 = 0;
        int r23 = 0;
        int r24 = 0;
        int r25 = 0;
        int label = 0;
        i7 = sp + numDefineNeg16;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r0 = r0 >> numDefine2;
        r1 = heapClassInst.heap32[r0 + numDefine2];
        if (!(r1 < 1)) {
            r1 = heapClassInst.heap32[fp + 1];
            heapClassInst.heap32[fp + numDefineNeg2] = r1;
            r1 = 0;
            repeat3:
            while (true) {
                r2 = heapClassInst.heap32[r0 + numDefine4];
                r3 = r1 << numDefine2;
                r2 = (r2 + r3) | 0;
                r2 = r2 >> numDefine2;
                r2 = heapClassInst.heap32[r2];
                r3 = r2 >> numDefine2;
                r4 = heapClassInst.heap32[r3 + numDefine58];
                if (!(r4 != 1)) {
                    r3 = heapClassInst.heap32[r3];
                    r3 = r3 >> numDefine2;
                    r3 = heapClassInst.heap32[r3 + numDefine6];
                    heapClassInst.heap32[g0] = r2;
                    r2 = heapClassInst.heap32[fp + numDefineNeg2];
                    heapClassInst.heap32[g0 + 1] = r2;
                    functionTable.get(r3 >> numDefine2).accept(i7);
                }
                r1 = (r1 + 1) | 0;
                r2 = heapClassInst.heap32[r0 + numDefine2];
                if (!(r2 > r1)) {
                    break repeat3;
                }
            }
            if (!(r2 < 1)) {
                r1 = 0;
                r2 = r1;
                r3 = r1;
                r4 = r1;
                r5 = r1;
                r6 = r1;
                heapClassInst.heap32[fp + -1] = r1;
                r7 = r1;
                r8 = r1;
                r9 = r1;
                r10 = r1;
                r11 = r1;
                r12 = r1;
                repeat10:
                while (true) {
                    r13 = heapClassInst.heap32[r0 + numDefine4];
                    r14 = r12 << numDefine2;
                    r13 = (r13 + r14) | 0;
                    r13 = r13 >> numDefine2;
                    r13 = heapClassInst.heap32[r13];
                    r13 = r13 >> numDefine2;
                    r13 = heapClassInst.heap32[r13 + numDefine48];
                    r14 = r13 << numDefine15;
                    r14 = r14 ^ -1;
                    r14 = (r13 + r14) | 0;
                    r15 = r14 >> numDefine10;
                    r14 = r15 ^ r14;
                    r14 = (r14 * numDefine9) | 0;
                    r15 = r14 >> numDefine6;
                    r14 = r15 ^ r14;
                    r15 = r14 << numDefine11;
                    r15 = r15 ^ -1;
                    r14 = (r14 + r15) | 0;
                    r15 = r14 >> numDefine16;
                    r14 = r15 ^ r14;
                    r15 = (r4 + -1) | 0;
                    r15 = r14 & r15;
                    r12 = (r12 + 1) | 0;
                    repeat12:
                    do {
                        if (uint(r10) <= uint(r15)) {
                            label = numDefine19;
                        } else {
                            r16 = r15 << numDefine2;
                            r17 = (r8 + r16) | 0;
                            repeat14:
                            while (true) {
                                r17 = r17 >> numDefine2;
                                r17 = heapClassInst.heap32[r17];
                                if (r17 == -1) {
                                    label = numDefine13;
                                    break repeat14;
                                } else {
                                    r18 = r17 << numDefine3;
                                    r18 = (r11 + r18) | 0;
                                    r18 = r18 >> numDefine2;
                                    r18 = heapClassInst.heap32[r18];
                                    if (r13 != r18) {
                                        r17 = r17 << numDefine2;
                                        r17 = (r6 + r17) | 0;
                                    } else {
                                        label = numDefine12;
                                        break repeat14;
                                    }
                                }
                            }
                            if (label == numDefine12) {
                                r17 = r17 << numDefine2;
                                r17 = (r3 + r17) | 0;
                                if (!(r17 == 0)) {
                                    label = numDefine89;
                                    break repeat12;
                                }
                            }
                            if (uint(r10) <= uint(r15)) {
                                label = numDefine19;
                            } else {
                                r16 = (r8 + r16) | 0;
                                repeat22:
                                while (true) {
                                    r16 = r16 >> numDefine2;
                                    r16 = heapClassInst.heap32[r16];
                                    if (r16 == -1) {
                                        label = numDefine19;
                                        break repeat12;
                                    } else {
                                        r17 = r16 << numDefine3;
                                        r17 = (r11 + r17) | 0;
                                        r17 = r17 >> numDefine2;
                                        r17 = heapClassInst.heap32[r17];
                                        if (r13 != r17) {
                                            r16 = r16 << numDefine2;
                                            r16 = (r6 + r16) | 0;
                                        } else {
                                            break repeat22;
                                        }
                                    }
                                }
                                r14 = r16 << numDefine2;
                                r14 = (r3 + r14) | 0;
                                r14 = r14 >> numDefine2;
                                heapClassInst.heap32[r14] = r13;
                                r16 = r4;
                                r17 = r5;
                                label = numDefine88;
                            }
                        }
                    } while (false);
                    if (label == numDefine19) {
                        if (r4 == r5) {
                            r16 = 1;
                            r17 = r5 << 1;
                            r16 = r5 == 0 ? r16 : r17;
                            if (r4 >= r16) {
                                label = numDefine20;
                            } else {
                                if (r16 != 0) {
                                    r17 = gNumAlignedAllocs;
                                    r17 = r17 >> numDefine2;
                                    r18 = heapClassInst.heap32[r17];
                                    r19 = r16 << numDefine2;
                                    r18 = (r18 + 1) | 0;
                                    r19 = r19 | numDefine3;
                                    heapClassInst.heap32[r17] = r18;
                                    r17 = (r19 + numDefine16) | 0;
                                    heapClassInst.heap32[g0] = r17;
                                    mallocNew(i7);
                                    r17 = commonVariable.rg0;
                                    if (r17 != 0) {
                                        r18 = 0;
                                        r19 = (r17 + numDefine4) | 0;
                                        r18 = (r18 - r19) | 0;
                                        r18 = r18 & numDefine15;
                                        r18 = (r17 + r18) | 0;
                                        r19 = (r18 + numDefine4) | 0;
                                        r18 = r18 >> numDefine2;
                                        heapClassInst.heap32[r18] = r17;
                                        r17 = r19;
                                    }
                                } else {
                                    r17 = 0;
                                }
                                repeat37:
                                do {
                                    if (!(r5 < 1)) {
                                        r18 = r17;
                                        r19 = r3;
                                        r20 = r5;
                                        while (true) {
                                            r21 = r19 >> numDefine2;
                                            r20 = (r20 + -1) | 0;
                                            r19 = (r19 + numDefine4) | 0;
                                            r22 = (r18 + numDefine4) | 0;
                                            r18 = r18 >> numDefine2;
                                            r21 = heapClassInst.heap32[r21];
                                            heapClassInst.heap32[r18] = r21;
                                            r18 = r22;
                                            if (!(r20 != 0)) {
                                                break repeat37;
                                            }
                                        }
                                    }
                                } while (false);
                                if (r3 != 0) {
                                    r18 = gNumAlignedFree;
                                    r18 = r18 >> numDefine2;
                                    r19 = heapClassInst.heap32[r18];
                                    r19 = (r19 + 1) | 0;
                                    r3 = r3 >> numDefine2;
                                    heapClassInst.heap32[r18] = r19;
                                    r3 = heapClassInst.heap32[r3 + -1];
                                    heapClassInst.heap32[g0] = r3;
                                    free(i7);
                                    r3 = r17;
                                    label = numDefine32;
                                } else {
                                    r3 = r17;
                                    label = numDefine32;
                                }
                            }
                        } else {
                            label = numDefine20;
                        }
                        if (label == numDefine20) {
                            r16 = r4;
                        }
                        r18 = r5 << numDefine2;
                        r19 = (r3 + r18) | 0;
                        r17 = (r5 + 1) | 0;
                        r19 = r19 >> numDefine2;
                        heapClassInst.heap32[r19] = r13;
                        if (r1 == r2) {
                            r19 = 1;
                            r20 = r2 << 1;
                            r19 = r2 == 0 ? r19 : r20;
                            if (!(r1 >= r19)) {
                                if (r19 != 0) {
                                    r1 = gNumAlignedAllocs;
                                    r1 = r1 >> numDefine2;
                                    r20 = heapClassInst.heap32[r1];
                                    r21 = r19 << numDefine3;
                                    r20 = (r20 + 1) | 0;
                                    r21 = r21 | numDefine3;
                                    heapClassInst.heap32[r1] = r20;
                                    r1 = (r21 + numDefine16) | 0;
                                    heapClassInst.heap32[g0] = r1;
                                    mallocNew(i7);
                                    r20 = commonVariable.rg0;
                                    if (r20 != 0) {
                                        r1 = 0;
                                        r21 = (r20 + numDefine4) | 0;
                                        r1 = (r1 - r21) | 0;
                                        r1 = r1 & numDefine15;
                                        r1 = (r20 + r1) | 0;
                                        r21 = (r1 + numDefine4) | 0;
                                        r1 = r1 >> numDefine2;
                                        heapClassInst.heap32[r1] = r20;
                                        r20 = r21;
                                    }
                                } else {
                                    r20 = 0;
                                }
                                repeat56:
                                do {
                                    if (!(r2 < 1)) {
                                        r1 = (r11 + numDefine4) | 0;
                                        r21 = (r20 + numDefine4) | 0;
                                        r22 = r2;
                                        while (true) {
                                            r23 = r1 >> numDefine2;
                                            r24 = heapClassInst.heap32[r23];
                                            r23 = heapClassInst.heap32[r23 + -1];
                                            r25 = r21 >> numDefine2;
                                            r22 = (r22 + -1) | 0;
                                            r1 = (r1 + numDefine8) | 0;
                                            r21 = (r21 + numDefine8) | 0;
                                            heapClassInst.heap32[r25 + -1] = r23;
                                            heapClassInst.heap32[r25] = r24;
                                            if (!(r22 != 0)) {
                                                break repeat56;
                                            }
                                        }
                                    }
                                } while (false);
                                if (r11 != 0) {
                                    r1 = gNumAlignedFree;
                                    r1 = r1 >> numDefine2;
                                    r21 = heapClassInst.heap32[r1];
                                    r21 = (r21 + 1) | 0;
                                    r11 = r11 >> numDefine2;
                                    heapClassInst.heap32[r1] = r21;
                                    r1 = heapClassInst.heap32[r11 + -1];
                                    heapClassInst.heap32[g0] = r1;
                                    free(i7);
                                    r1 = r19;
                                    r11 = r20;
                                } else {
                                    r1 = r19;
                                    r11 = r20;
                                }
                            }
                        }
                        r19 = r2 << numDefine3;
                        r19 = (r11 + r19) | 0;
                        r2 = (r2 + 1) | 0;
                        r19 = r19 >> numDefine2;
                        heapClassInst.heap32[r19] = r13;
                        if (r4 < r16) {
                            if (r10 < r16) {
                                repeat69:
                                do {
                                    if (r10 <= r16) {
                                        if (r9 < r16) {
                                            if (r16 != 0) {
                                                r4 = gNumAlignedAllocs;
                                                r4 = r4 >> numDefine2;
                                                r9 = heapClassInst.heap32[r4];
                                                r15 = r16 << numDefine2;
                                                r9 = (r9 + 1) | 0;
                                                r15 = r15 | numDefine3;
                                                heapClassInst.heap32[r4] = r9;
                                                r4 = (r15 + numDefine16) | 0;
                                                heapClassInst.heap32[g0] = r4;
                                                mallocNew(i7);
                                                r4 = commonVariable.rg0;
                                                if (r4 != 0) {
                                                    r9 = 0;
                                                    r15 = (r4 + numDefine4) | 0;
                                                    r9 = (r9 - r15) | 0;
                                                    r9 = r9 & numDefine15;
                                                    r9 = (r4 + r9) | 0;
                                                    r15 = (r9 + numDefine4) | 0;
                                                    r9 = r9 >> numDefine2;
                                                    heapClassInst.heap32[r9] = r4;
                                                    r4 = r15;
                                                }
                                            } else {
                                                r4 = 0;
                                            }
                                            repeat78:
                                            do {
                                                if (!(r10 < 1)) {
                                                    r9 = r4;
                                                    r15 = r8;
                                                    r19 = r10;
                                                    while (true) {
                                                        r20 = r15 >> numDefine2;
                                                        r19 = (r19 + -1) | 0;
                                                        r15 = (r15 + numDefine4) | 0;
                                                        r21 = (r9 + numDefine4) | 0;
                                                        r9 = r9 >> numDefine2;
                                                        r20 = heapClassInst.heap32[r20];
                                                        heapClassInst.heap32[r9] = r20;
                                                        r9 = r21;
                                                        if (!(r19 != 0)) {
                                                            break repeat78;
                                                        }
                                                    }
                                                }
                                            } while (false);
                                            if (r8 != 0) {
                                                r9 = gNumAlignedFree;
                                                r9 = r9 >> numDefine2;
                                                r15 = heapClassInst.heap32[r9];
                                                r15 = (r15 + 1) | 0;
                                                r8 = r8 >> numDefine2;
                                                heapClassInst.heap32[r9] = r15;
                                                r8 = heapClassInst.heap32[r8 + -1];
                                                heapClassInst.heap32[g0] = r8;
                                                free(i7);
                                                r8 = r4;
                                                r9 = r16;
                                            } else {
                                                r8 = r4;
                                                r9 = r16;
                                            }
                                        }
                                        r4 = r10;
                                        while (true) {
                                            r15 = r4 << numDefine2;
                                            r15 = (r8 + r15) | 0;
                                            r4 = (r4 + 1) | 0;
                                            r15 = r15 >> numDefine2;
                                            heapClassInst.heap32[r15] = 0;
                                            if (!(r16 != r4)) {
                                                break repeat69;
                                            }
                                        }
                                    }
                                } while (false);
                                repeat90:
                                do {
                                    if (r7 <= r16) {
                                        if (!(r7 >= r16)) {
                                            r4 = heapClassInst.heap32[fp + -1];
                                            if (r4 < r16) {
                                                if (r16 != 0) {
                                                    r4 = gNumAlignedAllocs;
                                                    r4 = r4 >> numDefine2;
                                                    r15 = heapClassInst.heap32[r4];
                                                    r19 = r16 << numDefine2;
                                                    r15 = (r15 + 1) | 0;
                                                    r19 = r19 | numDefine3;
                                                    heapClassInst.heap32[r4] = r15;
                                                    r4 = (r19 + numDefine16) | 0;
                                                    heapClassInst.heap32[g0] = r4;
                                                    mallocNew(i7);
                                                    r4 = commonVariable.rg0;
                                                    if (r4 != 0) {
                                                        r15 = 0;
                                                        r19 = (r4 + numDefine4) | 0;
                                                        r15 = (r15 - r19) | 0;
                                                        r15 = r15 & numDefine15;
                                                        r15 = (r4 + r15) | 0;
                                                        r19 = (r15 + numDefine4) | 0;
                                                        r15 = r15 >> numDefine2;
                                                        heapClassInst.heap32[r15] = r4;
                                                        r4 = r19;
                                                    }
                                                } else {
                                                    r4 = 0;
                                                }
                                                repeat100:
                                                do {
                                                    if (!(r7 < 1)) {
                                                        r15 = r4;
                                                        r19 = r6;
                                                        r20 = r7;
                                                        while (true) {
                                                            r21 = r19 >> numDefine2;
                                                            r20 = (r20 + -1) | 0;
                                                            r19 = (r19 + numDefine4) | 0;
                                                            r22 = (r15 + numDefine4) | 0;
                                                            r15 = r15 >> numDefine2;
                                                            r21 = heapClassInst.heap32[r21];
                                                            heapClassInst.heap32[r15] = r21;
                                                            r15 = r22;
                                                            if (!(r20 != 0)) {
                                                                break repeat100;
                                                            }
                                                        }
                                                    }
                                                } while (false);
                                                if (!(r6 == 0)) {
                                                    r15 = gNumAlignedFree;
                                                    r15 = r15 >> numDefine2;
                                                    r19 = heapClassInst.heap32[r15];
                                                    r19 = (r19 + 1) | 0;
                                                    r6 = r6 >> numDefine2;
                                                    heapClassInst.heap32[r15] = r19;
                                                    r6 = heapClassInst.heap32[r6 + -1];
                                                    heapClassInst.heap32[g0] = r6;
                                                    free(i7);
                                                }
                                                if (r7 < r16) {
                                                    r6 = r4;
                                                    heapClassInst.heap32[fp + -1] = r16;
                                                } else {
                                                    r6 = r4;
                                                    heapClassInst.heap32[fp + -1] = r16;
                                                    break repeat90;
                                                }
                                            }
                                            while (true) {
                                                r4 = r7 << numDefine2;
                                                r4 = (r6 + r4) | 0;
                                                r7 = (r7 + 1) | 0;
                                                r4 = r4 >> numDefine2;
                                                heapClassInst.heap32[r4] = 0;
                                                if (!(r16 != r7)) {
                                                    break repeat90;
                                                }
                                            }
                                        }
                                    }
                                } while (false);
                                repeat114:
                                do {
                                    if (!(r16 < 1)) {
                                        r4 = r8;
                                        r7 = r16;
                                        repeat116:
                                        while (true) {
                                            r7 = (r7 + -1) | 0;
                                            r15 = (r4 + numDefine4) | 0;
                                            r4 = r4 >> numDefine2;
                                            heapClassInst.heap32[r4] = -1;
                                            r4 = r15;
                                            if (!(r7 != 0)) {
                                                break repeat116;
                                            }
                                        }
                                        if (!(r16 < 1)) {
                                            r4 = r6;
                                            r7 = r16;
                                            while (true) {
                                                r7 = (r7 + -1) | 0;
                                                r15 = (r4 + numDefine4) | 0;
                                                r4 = r4 >> numDefine2;
                                                heapClassInst.heap32[r4] = -1;
                                                r4 = r15;
                                                if (!(r7 != 0)) {
                                                    break repeat114;
                                                }
                                            }
                                        }
                                    }
                                } while (false);
                                repeat123:
                                do {
                                    if (r10 > 0) {
                                        r4 = (r16 + -1) | 0;
                                        r7 = 0;
                                        while (true) {
                                            r15 = r7 << numDefine3;
                                            r15 = (r11 + r15) | 0;
                                            r15 = r15 >> numDefine2;
                                            r15 = heapClassInst.heap32[r15];
                                            r19 = r15 << numDefine15;
                                            r19 = r19 ^ -1;
                                            r15 = (r15 + r19) | 0;
                                            r19 = r15 >> numDefine10;
                                            r15 = r19 ^ r15;
                                            r15 = (r15 * numDefine9) | 0;
                                            r19 = r15 >> numDefine6;
                                            r15 = r19 ^ r15;
                                            r19 = r15 << numDefine11;
                                            r19 = r19 ^ -1;
                                            r15 = (r15 + r19) | 0;
                                            r19 = r15 >> numDefine16;
                                            r15 = r19 ^ r15;
                                            r15 = r15 & r4;
                                            r15 = r15 << numDefine2;
                                            r15 = (r8 + r15) | 0;
                                            r15 = r15 >> numDefine2;
                                            r19 = r7 << numDefine2;
                                            r19 = (r6 + r19) | 0;
                                            r20 = heapClassInst.heap32[r15];
                                            r19 = r19 >> numDefine2;
                                            r21 = (r7 + 1) | 0;
                                            heapClassInst.heap32[r19] = r20;
                                            heapClassInst.heap32[r15] = r7;
                                            r7 = r21;
                                            if (r10 == r21) {
                                                break repeat123;
                                            }
                                        }
                                    }
                                } while (false);
                                r7 = r16;
                                r10 = r16;
                            }
                            r4 = (r16 + -1) | 0;
                            r15 = r14 & r4;
                        }
                        r4 = r15 << numDefine2;
                        r4 = (r8 + r4) | 0;
                        r4 = r4 >> numDefine2;
                        r14 = (r6 + r18) | 0;
                        r14 = r14 >> numDefine2;
                        r15 = heapClassInst.heap32[r4];
                        heapClassInst.heap32[r14] = r15;
                        heapClassInst.heap32[r4] = r5;
                        label = numDefine88;
                    }
                    if (label == numDefine88) {
                        r4 = r13 >> numDefine2;
                        r4 = heapClassInst.heap32[r4];
                        r4 = r4 >> numDefine2;
                        r4 = heapClassInst.heap32[r4 + numDefine14];
                        heapClassInst.heap32[g0] = r13;
                        r5 = heapClassInst.heap32[fp + numDefineNeg2];
                        heapClassInst.heap32[g0 + 1] = r5;
                        functionTable.get(r4 >> numDefine2).accept(i7);
                        r4 = r16;
                        r5 = r17;
                    }
                    r13 = heapClassInst.heap32[r0 + numDefine2];
                    if (!(r13 > r12)) {
                        break repeat10;
                    }
                }
                if (!(r11 == 0)) {
                    r0 = gNumAlignedFree;
                    r0 = r0 >> numDefine2;
                    r1 = heapClassInst.heap32[r0];
                    r1 = (r1 + 1) | 0;
                    r2 = r11 >> numDefine2;
                    heapClassInst.heap32[r0] = r1;
                    r0 = heapClassInst.heap32[r2 + -1];
                    heapClassInst.heap32[g0] = r0;
                    free(i7);
                }
                if (!(r3 == 0)) {
                    r0 = gNumAlignedFree;
                    r0 = r0 >> numDefine2;
                    r1 = heapClassInst.heap32[r0];
                    r1 = (r1 + 1) | 0;
                    r2 = r3 >> numDefine2;
                    heapClassInst.heap32[r0] = r1;
                    r0 = heapClassInst.heap32[r2 + -1];
                    heapClassInst.heap32[g0] = r0;
                    free(i7);
                }
                if (!(r6 == 0)) {
                    r0 = gNumAlignedFree;
                    r0 = r0 >> numDefine2;
                    r1 = heapClassInst.heap32[r0];
                    r1 = (r1 + 1) | 0;
                    r2 = r6 >> numDefine2;
                    heapClassInst.heap32[r0] = r1;
                    r0 = heapClassInst.heap32[r2 + -1];
                    heapClassInst.heap32[g0] = r0;
                    free(i7);
                }
                if (!(r8 == 0)) {
                    r0 = gNumAlignedFree;
                    r0 = r0 >> numDefine2;
                    r1 = heapClassInst.heap32[r0];
                    r1 = (r1 + 1) | 0;
                    r2 = r8 >> numDefine2;
                    heapClassInst.heap32[r0] = r1;
                    r0 = heapClassInst.heap32[r2 + -1];
                    heapClassInst.heap32[g0] = r0;
                    free(i7);
                }
            }
        }
        return;
    }

    public static void zn16btWorldQuery(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int label = 0;
        i7 = sp + numDefineNeg8;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = ztv18btTriangleCallback;
        r2 = r0 >> numDefine2;
        r1 = (r1 + numDefine8) | 0;
        heapClassInst.heap32[r2] = r1;
        heapClassInst.heap32[g0] = r0;
        zdlPv(i7);
        
    }

    public static void zzn16btCollisionWorld(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int label = 0;
        i7 = sp + 0;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = ztv18btTriangleCallback;
        r0 = r0 >> numDefine2;
        r1 = (r1 + numDefine8) | 0;
        heapClassInst.heap32[r0] = r1;
        
    }

    public static void zn16btRayResultCallbackENBridge(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int label = 0;
        i7 = sp + numDefineNeg8;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = ztv18btTriangleCallback;
        r2 = r0 >> numDefine2;
        r1 = (r1 + numDefine8) | 0;
        heapClassInst.heap32[r2] = r1;
        heapClassInst.heap32[g0] = r0;
        zdlPv(i7);
        
    }

    public static void zn16btRayResultCallback(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int label = 0;
        i7 = sp + 0;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = ztv18btTriangleCallback;
        r0 = r0 >> numDefine2;
        r1 = (r1 + numDefine8) | 0;
        heapClassInst.heap32[r0] = r1;
        
    }

    public static void zn16btCollisionShapeRayResult(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int label = 0;
        i7 = sp + numDefineNeg8;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = ztv18btTriangleCallback;
        r2 = r0 >> numDefine2;
        r1 = (r1 + numDefine8) | 0;
        heapClassInst.heap32[r2] = r1;
        heapClassInst.heap32[g0] = r0;
        zdlPv(i7);
        
    }

    public static void zn16btCollisionShape(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int label = 0;
        i7 = sp + 0;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = ztv18btTriangleCallback;
        r0 = r0 >> numDefine2;
        r1 = (r1 + numDefine8) | 0;
        heapClassInst.heap32[r0] = r1;
        
    }

    public static void zn16btCollisionWorldTest(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int label = 0;
        i7 = sp + numDefineNeg8;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = ztv18btTriangleCallback;
        r2 = r0 >> numDefine2;
        r1 = (r1 + numDefine8) | 0;
        heapClassInst.heap32[r2] = r1;
        heapClassInst.heap32[g0] = r0;
        zdlPv(i7);
        
    }

    public static void zn16btCollisionWorld(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int label = 0;
        i7 = sp + 0;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = ztv18btTriangleCallback;
        r0 = r0 >> numDefine2;
        r1 = (r1 + numDefine8) | 0;
        heapClassInst.heap32[r0] = r1;
        
    }

    public static void znk16btCollisionWorld15convexSweepTestEPK13btConvexShapeRK11btTransformS5RNS20ConvexResultCallbackEf(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        int r6 = 0;
        int r7 = 0;
        int r8 = 0;
        int r9 = 0;
        int r10 = 0;
        float f0 = 0.0F;
        float f1 = 0.0F;
        float f2 = 0.0F;
        float f3 = 0.0F;
        float f4 = 0.0F;
        float f5 = 0.0F;
        float f6 = 0.0F;
        float f7 = 0.0F;
        float f8 = 0.0F;
        float f9 = 0.0F;
        float f10 = 0.0F;
        float f11 = 0.0F;
        float f12 = 0.0F;
        float f13 = 0.0F;
        int label = 0;
        i7 = sp + numDefineNeg528;
        int g0 = i7 >> numDefine2;
        r0 = twoEStr1089;
        r1 = heapClassInst.heap32[fp + numDefine2];
        heapClassInst.heap32[g0] = r0;
        r0 = sp + numDefineNeg112;
        r1 = r1 >> numDefine2;
        zn15CProfileManager13StartProfileEPKc(i7);
        r2 = r0 >> numDefine2;
        heapClassInst.heap32[fp + numDefineNeg28] = heapClassInst.heap32[r1];
        heapClassInst.heap32[r2 + 1] = heapClassInst.heap32[r1 + 1];
        heapClassInst.heap32[r2 + numDefine2] = heapClassInst.heap32[r1 + numDefine2];
        heapClassInst.heap32[r2 + numDefine3] = heapClassInst.heap32[r1 + numDefine3];
        heapClassInst.heap32[r2 + numDefine4] = heapClassInst.heap32[r1 + numDefine4];
        heapClassInst.heap32[r2 + numDefine5] = heapClassInst.heap32[r1 + numDefine5];
        heapClassInst.heap32[r2 + numDefine6] = heapClassInst.heap32[r1 + numDefine6];
        heapClassInst.heap32[r2 + numDefine7] = heapClassInst.heap32[r1 + numDefine7];
        heapClassInst.heap32[r2 + numDefine8] = heapClassInst.heap32[r1 + numDefine8];
        heapClassInst.heap32[r2 + numDefine9] = heapClassInst.heap32[r1 + numDefine9];
        heapClassInst.heap32[r2 + numDefine10] = heapClassInst.heap32[r1 + numDefine10];
        heapClassInst.heap32[r2 + numDefine11] = heapClassInst.heap32[r1 + numDefine11];
        heapClassInst.heap32[r2 + numDefine12] = heapClassInst.heap32[r1 + numDefine12];
        heapClassInst.heap32[r2 + numDefine13] = heapClassInst.heap32[r1 + numDefine13];
        r3 = heapClassInst.heap32[fp + numDefine3];
        heapClassInst.heap32[r2 + numDefine14] = heapClassInst.heap32[r1 + numDefine14];
        r4 = sp + numDefineNeg176;
        r3 = r3 >> numDefine2;
        heapClassInst.heap32[r2 + numDefine15] = heapClassInst.heap32[r1 + numDefine15];
        r2 = r4 >> numDefine2;
        heapClassInst.heap32[fp + numDefineNeg44] = heapClassInst.heap32[r3];
        heapClassInst.heap32[r2 + 1] = heapClassInst.heap32[r3 + 1];
        heapClassInst.heap32[r2 + numDefine2] = heapClassInst.heap32[r3 + numDefine2];
        heapClassInst.heap32[r2 + numDefine3] = heapClassInst.heap32[r3 + numDefine3];
        heapClassInst.heap32[r2 + numDefine4] = heapClassInst.heap32[r3 + numDefine4];
        heapClassInst.heap32[r2 + numDefine5] = heapClassInst.heap32[r3 + numDefine5];
        heapClassInst.heap32[r2 + numDefine6] = heapClassInst.heap32[r3 + numDefine6];
        heapClassInst.heap32[r2 + numDefine7] = heapClassInst.heap32[r3 + numDefine7];
        heapClassInst.heap32[r2 + numDefine8] = heapClassInst.heap32[r3 + numDefine8];
        heapClassInst.heap32[r2 + numDefine9] = heapClassInst.heap32[r3 + numDefine9];
        heapClassInst.heap32[r2 + numDefine10] = heapClassInst.heap32[r3 + numDefine10];
        heapClassInst.heap32[r2 + numDefine11] = heapClassInst.heap32[r3 + numDefine11];
        heapClassInst.heap32[r2 + numDefine12] = heapClassInst.heap32[r3 + numDefine12];
        heapClassInst.heap32[r2 + numDefine13] = heapClassInst.heap32[r3 + numDefine13];
        heapClassInst.heap32[r2 + numDefine14] = heapClassInst.heap32[r3 + numDefine14];
        heapClassInst.heap32[r2 + numDefine15] = heapClassInst.heap32[r3 + numDefine15];
        r2 = sp + numDefineNeg24;
        r5 = sp + numDefineNeg28;
        heapClassInst.heap32[g0] = r0;
        heapClassInst.heap32[g0 + 1] = r4;
        heapClassInst.heap32[g0 + numDefine2] = r2;
        heapClassInst.heap32[g0 + numDefine3] = r5;
        zn15btTransformUtil22calculateDiffAxisAngleERK11btTransformS2R9btVector3Rf(i7);
        r2 = r2 >> numDefine2;
        f0 = heapClassInst.heapFloat[r2 + numDefine2];
        f1 = heapClassInst.heapFloat[fp + numDefineNeg7];
        f2 = heapClassInst.heapFloat[r2 + 1];
        f3 = heapClassInst.heapFloat[fp + numDefineNeg6];
        r2 = sp + numDefineNeg424;
        f3 = f3 * f1;
        r5 = r2 >> numDefine2;
        f2 = f2 * f1;
        heapClassInst.heapFloat[fp + numDefineNeg106] = f3;
        f0 = f0 * f1;
        heapClassInst.heapFloat[r5 + 1] = f2;
        heapClassInst.heapFloat[r5 + numDefine2] = f0;
        r6 = sp + numDefineNeg440;
        heapClassInst.heap32[r5 + numDefine3] = 0;
        r5 = r6 >> numDefine2;
        heapClassInst.heap32[fp + numDefineNeg110] = 0;
        heapClassInst.heap32[r5 + 1] = 0;
        heapClassInst.heap32[r5 + numDefine2] = 0;
        r7 = sp + numDefineNeg504;
        heapClassInst.heap32[r5 + numDefine3] = 0;
        r5 = r7 >> numDefine2;
        heapClassInst.heap32[fp + numDefineNeg126] = numDefine53216;
        heapClassInst.heap32[r5 + 1] = 0;
        heapClassInst.heap32[r5 + numDefine2] = 0;
        heapClassInst.heap32[r5 + numDefine3] = 0;
        heapClassInst.heap32[r5 + numDefine4] = 0;
        heapClassInst.heap32[r5 + numDefine5] = numDefine53216;
        heapClassInst.heap32[r5 + numDefine6] = 0;
        heapClassInst.heap32[r5 + numDefine7] = 0;
        heapClassInst.heap32[r5 + numDefine8] = 0;
        heapClassInst.heap32[r5 + numDefine9] = 0;
        heapClassInst.heap32[r5 + numDefine10] = numDefine53216;
        heapClassInst.heap32[r5 + numDefine11] = 0;
        heapClassInst.heap32[r5 + numDefine12] = 0;
        heapClassInst.heap32[r5 + numDefine13] = 0;
        heapClassInst.heap32[r5 + numDefine14] = 0;
        heapClassInst.heap32[r5 + numDefine15] = 0;
        r8 = sp + numDefineNeg48;
        heapClassInst.heap32[g0] = r0;
        heapClassInst.heap32[g0 + 1] = r8;
        znk11btMatrix3x311getRotationER12btQuaternion(i7);
        r8 = r8 >> numDefine2;
        f0 = heapClassInst.heapFloat[fp + numDefineNeg12];
        f1 = heapClassInst.heapFloat[r8 + 1];
        f2 = heapClassInst.heapFloat[r8 + numDefine2];
        f3 = f0 * f0;
        f4 = f1 * f1;
        f5 = heapClassInst.heapFloat[r8 + numDefine3];
        f3 = f3 + f4;
        f4 = f2 * f2;
        f3 = f3 + f4;
        f4 = f5 * f5;
        f6 = numDefine2;
        f3 = f3 + f4;
        f3 = f6 / f3;
        f4 = f2 * f3;
        f6 = f1 * f3;
        f7 = f1 * f6;
        f2 = f2 * f4;
        f8 = f7 + f2;
        f9 = 1;
        f10 = f0 * f6;
        f11 = f5 * f4;
        f8 = f9 - f8;
        f12 = f0 * f4;
        f6 = f5 * f6;
        f13 = f10 - f11;
        heapClassInst.heapFloat[fp + numDefineNeg126] = f8;
        f3 = f0 * f3;
        f8 = f12 + f6;
        heapClassInst.heapFloat[r5 + 1] = f13;
        f0 = f0 * f3;
        heapClassInst.heapFloat[r5 + numDefine2] = f8;
        f2 = f0 + f2;
        f8 = f10 + f11;
        heapClassInst.heap32[r5 + numDefine3] = 0;
        f1 = f1 * f4;
        f3 = f5 * f3;
        f2 = f9 - f2;
        heapClassInst.heapFloat[r5 + numDefine4] = f8;
        f4 = f1 - f3;
        heapClassInst.heapFloat[r5 + numDefine5] = f2;
        heapClassInst.heapFloat[r5 + numDefine6] = f4;
        f2 = f12 - f6;
        heapClassInst.heap32[r5 + numDefine7] = 0;
        f0 = f0 + f7;
        f1 = f1 + f3;
        heapClassInst.heapFloat[r5 + numDefine8] = f2;
        f0 = f9 - f0;
        heapClassInst.heapFloat[r5 + numDefine9] = f1;
        heapClassInst.heapFloat[r5 + numDefine10] = f0;
        heapClassInst.heap32[r5 + numDefine11] = 0;
        r5 = heapClassInst.heap32[fp + 1];
        r8 = sp + numDefineNeg192;
        r9 = sp + numDefineNeg208;
        heapClassInst.heap32[g0] = r5;
        heapClassInst.heap32[g0 + 1] = r7;
        heapClassInst.heap32[g0 + numDefine2] = r6;
        heapClassInst.heap32[g0 + numDefine3] = r2;
        heapClassInst.heap32[g0 + numDefine4] = r8;
        heapClassInst.heap32[g0 + numDefine5] = r9;
        r2 = ztv21btSingleSweepCallback;
        r6 = sp + numDefineNeg408;
        r2 = (r2 + numDefine8) | 0;
        znk16btCollisionShape21calculateTemporalAabbERK11btTransformRK9btVector3S5FRS3S6(i7);
        r7 = r6 >> numDefine2;
        heapClassInst.heap32[fp + numDefineNeg102] = r2;
        heapClassInst.heap32[r7 + numDefine9] = heapClassInst.heap32[r1];
        heapClassInst.heap32[r7 + numDefine10] = heapClassInst.heap32[r1 + 1];
        heapClassInst.heap32[r7 + numDefine11] = heapClassInst.heap32[r1 + numDefine2];
        heapClassInst.heap32[r7 + numDefine12] = heapClassInst.heap32[r1 + numDefine3];
        heapClassInst.heap32[r7 + numDefine13] = heapClassInst.heap32[r1 + numDefine4];
        heapClassInst.heap32[r7 + numDefine14] = heapClassInst.heap32[r1 + numDefine5];
        heapClassInst.heap32[r7 + numDefine15] = heapClassInst.heap32[r1 + numDefine6];
        heapClassInst.heap32[r7 + numDefine16] = heapClassInst.heap32[r1 + numDefine7];
        heapClassInst.heap32[r7 + numDefine17] = heapClassInst.heap32[r1 + numDefine8];
        heapClassInst.heap32[r7 + numDefine18] = heapClassInst.heap32[r1 + numDefine9];
        heapClassInst.heap32[r7 + numDefine19] = heapClassInst.heap32[r1 + numDefine10];
        heapClassInst.heap32[r7 + numDefine20] = heapClassInst.heap32[r1 + numDefine11];
        f0 = heapClassInst.heapFloat[r1 + numDefine12];
        heapClassInst.heapFloat[r7 + numDefine21] = f0;
        f1 = heapClassInst.heapFloat[r1 + numDefine13];
        heapClassInst.heapFloat[r7 + numDefine22] = f1;
        f2 = heapClassInst.heapFloat[r1 + numDefine14];
        heapClassInst.heapFloat[r7 + numDefine23] = f2;
        heapClassInst.heap32[r7 + numDefine24] = heapClassInst.heap32[r1 + numDefine15];
        heapClassInst.heap32[r7 + numDefine25] = heapClassInst.heap32[r3];
        heapClassInst.heap32[r7 + numDefine26] = heapClassInst.heap32[r3 + 1];
        heapClassInst.heap32[r7 + numDefine27] = heapClassInst.heap32[r3 + numDefine2];
        heapClassInst.heap32[r7 + numDefine28] = heapClassInst.heap32[r3 + numDefine3];
        heapClassInst.heap32[r7 + numDefine29] = heapClassInst.heap32[r3 + numDefine4];
        heapClassInst.heap32[r7 + numDefine30] = heapClassInst.heap32[r3 + numDefine5];
        heapClassInst.heap32[r7 + numDefine31] = heapClassInst.heap32[r3 + numDefine6];
        heapClassInst.heap32[r7 + numDefine32] = heapClassInst.heap32[r3 + numDefine7];
        heapClassInst.heap32[r7 + numDefine33] = heapClassInst.heap32[r3 + numDefine8];
        heapClassInst.heap32[r7 + numDefine34] = heapClassInst.heap32[r3 + numDefine9];
        heapClassInst.heap32[r7 + numDefine35] = heapClassInst.heap32[r3 + numDefine10];
        heapClassInst.heap32[r7 + numDefine36] = heapClassInst.heap32[r3 + numDefine11];
        f3 = heapClassInst.heapFloat[r3 + numDefine12];
        heapClassInst.heapFloat[r7 + numDefine37] = f3;
        f4 = heapClassInst.heapFloat[r3 + numDefine13];
        heapClassInst.heapFloat[r7 + numDefine38] = f4;
        f5 = heapClassInst.heapFloat[r3 + numDefine14];
        heapClassInst.heapFloat[r7 + numDefine39] = f5;
        r1 = heapClassInst.heap32[fp];
        heapClassInst.heap32[r7 + numDefine40] = heapClassInst.heap32[r3 + numDefine15];
        r3 = heapClassInst.heap32[fp + numDefine4];
        heapClassInst.heap32[r7 + numDefine45] = r1;
        heapClassInst.heap32[r7 + numDefine46] = r3;
        f0 = f3 - f0;
        f1 = f4 - f1;
        heapClassInst.heap32[r7 + numDefine47] = heapClassInst.heap32[fp + numDefine5];
        f2 = f5 - f2;
        heapClassInst.heap32[r7 + numDefine48] = r5;
        f3 = f0 * f0;
        f4 = f1 * f1;
        f3 = f3 + f4;
        f4 = f2 * f2;
        f3 = f3 + f4;
        heapClassInst.heapFloat[g0] = f3;
        sqrtf(i7);
        f3 = (float) (f9 / commonVariable.fg0);
        f4 = f0 * f3;
        f5 = f2 * f3;
        f3 = f1 * f3;
        f6 = 0;
        if (f4 != f6) {
            f7 = f9 / f4;
        } else {
            f7 = numDefine49440;
        }
        heapClassInst.heapFloat[r7 + 1] = f7;
        if (f3 != f6) {
            f8 = f9 / f3;
        } else {
            f8 = numDefine49440;
        }
        heapClassInst.heapFloat[r7 + numDefine2] = f8;
        if (f5 != f6) {
            f9 = f9 / f5;
        } else {
            f9 = numDefine49440;
        }

        r3 = f7 < f6 ? 1 : 0;
        r5 = f8 < f6 ? 1 : 0;

        r3 = r3 & 1;
        heapClassInst.heapFloat[r7 + numDefine3] = f9;
        r10 = f9 < f6 ? 1 : 0;
        f0 = f4 * f0;
        f1 = f3 * f1;
        r5 = r5 & 1;
        heapClassInst.heap32[r7 + numDefine5] = r3;
        f0 = f0 + f1;
        f1 = f5 * f2;
        r3 = r10 & 1;
        heapClassInst.heap32[r7 + numDefine6] = r5;
        f0 = f0 + f1;
        heapClassInst.heap32[r7 + numDefine7] = r3;
        r1 = r1 >> numDefine2;
        heapClassInst.heapFloat[r7 + numDefine8] = f0;
        r1 = heapClassInst.heap32[r1 + numDefine20];
        r3 = r1 >> numDefine2;
        r3 = heapClassInst.heap32[r3];
        r3 = r3 >> numDefine2;
        r3 = heapClassInst.heap32[r3 + numDefine6];
        r0 = (r0 + numDefine48) | 0;
        r4 = (r4 + numDefine48) | 0;
        heapClassInst.heap32[g0] = r1;
        heapClassInst.heap32[g0 + 1] = r0;
        heapClassInst.heap32[g0 + numDefine2] = r4;
        heapClassInst.heap32[g0 + numDefine3] = r6;
        heapClassInst.heap32[g0 + numDefine4] = r8;
        heapClassInst.heap32[g0 + numDefine5] = r9;
        r0 = zn15CProfileManager11CurrentNodeE;
        functionTable.get(r3 >> numDefine2).accept(i7);
        r0 = r0 >> numDefine2;
        heapClassInst.heap32[fp + numDefineNeg102] = r2;
        r1 = heapClassInst.heap32[r0];
        r2 = r1 >> numDefine2;
        r3 = heapClassInst.heap32[r2 + numDefine4];
        r3 = (r3 + -1) | 0;
        heapClassInst.heap32[r2 + numDefine4] = r3;
        repeat13:
        do {
            if (!(r3 != 0)) {
                r3 = heapClassInst.heap32[r2 + 1];
                if (r3 != 0) {
                    r1 = sp + numDefineNeg8;
                    heapClassInst.heap32[g0] = r1;
                    heapClassInst.heap32[g0 + 1] = 0;
                    r3 = zl13gProfileClock2E0;
                    getTimeOfDay(i7);
                    r3 = r3 >> numDefine2;
                    r3 = heapClassInst.heap32[r3];
                    r3 = r3 >> numDefine2;
                    r1 = r1 >> numDefine2;
                    r4 = heapClassInst.heap32[fp + numDefineNeg2];
                    r5 = heapClassInst.heap32[r3];
                    r4 = (r4 - r5) | 0;
                    r1 = heapClassInst.heap32[r1 + 1];
                    r3 = heapClassInst.heap32[r3 + 1];
                    r1 = (r1 - r3) | 0;
                    r3 = (int) ((r4 * numDefineN6) | 0);
                    r1 = (r1 + r3) | 0;
                    r3 = heapClassInst.heap32[r2 + numDefine3];
                    r1 = (r1 - r3) | 0;
                    f0 = uint(r1);
                    f1 = numDefine1000;
                    f2 = heapClassInst.heapFloat[r2 + numDefine2];
                    f0 = f0 / f1;
                    f0 = f2 + f0;
                    heapClassInst.heapFloat[r2 + numDefine2] = f0;
                    r1 = heapClassInst.heap32[r2 + numDefine4];
                    if (r1 != 0) {
                        break repeat13;
                    } else {
                        r1 = heapClassInst.heap32[r0];
                    }
                }
                r1 = r1 >> numDefine2;
                r1 = heapClassInst.heap32[r1 + numDefine5];
                heapClassInst.heap32[r0] = r1;
            }
        } while (false);
        return;
    }

    public static void zn16btCollisionWorld17objectQuerySingleEPK13btConvexShapeRK11btTransformS5P17btCollisionObjectPK16btCollisionShapeS5RNS20ConvexResultCallbackEf(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        int r6 = 0;
        int r7 = 0;
        int r8 = 0;
        int r9 = 0;
        int r10 = 0;
        int r11 = 0;
        int r12 = 0;
        int r13 = 0;
        int r14 = 0;
        int r15 = 0;
        float f0 = 0.0F;
        float f1 = 0.0F;
        float f2 = 0.0F;
        float f3 = 0.0F;
        float f4 = 0.0F;
        float f5 = 0.0F;
        float f6 = 0.0F;
        float f7 = 0.0F;
        float f8 = 0.0F;
        float f9 = 0.0F;
        float f10 = 0.0F;
        float f11 = 0.0F;
        float f12 = 0.0F;
        float f13 = 0.0F;
        float f14 = 0.0F;
        float f15 = 0.0F;
        float f16 = 0.0F;
        float f17 = 0.0F;
        float f18 = 0.0F;
        float f19 = 0.0F;
        float f20 = 0.0F;
        float f21 = 0.0F;
        float f22 = 0.0F;
        float f23 = 0.0F;
        float f24 = 0.0F;
        float f25 = 0.0F;
        float f26 = 0.0F;
        float f27 = 0.0F;
        float f28 = 0.0F;
        float f29 = 0.0F;
        float f30 = 0.0F;
        int label = 0;
        i7 = sp + numDefineNeg1472;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp + numDefine4];
        r1 = r0 >> numDefine2;
        r2 = heapClassInst.heap32[r1 + 1];
        r3 = heapClassInst.heap32[fp];
        r4 = heapClassInst.heap32[fp + 1];
        r5 = heapClassInst.heap32[fp + numDefine2];
        r6 = heapClassInst.heap32[fp + numDefine3];
        r7 = heapClassInst.heap32[fp + numDefine5];
        r8 = heapClassInst.heap32[fp + numDefine6];
        f0 = heapClassInst.heapFloat[fp + numDefine7];
        repeat1:
        do {
            if (r2 > numDefine19) {
                r9 = (r2 + numDefineNeg21) | 0;
                if (uint(r9) > uint(numDefine8)) {
                    if (r2 != numDefine31) {
                        break repeat1;
                    } else {
                        r0 = twoEStr1493;
                        heapClassInst.heap32[g0] = r0;
                        zn15CProfileManager13StartProfileEPKc(i7);
                        r0 = heapClassInst.heap32[r1 + numDefine4];
                        if (!(r0 < 1)) {
                            r0 = 0;
                            repeat8:
                            while (true) {
                                r2 = (r0 * numDefine20) | 0;
                                r9 = heapClassInst.heap32[r1 + numDefine6];
                                r2 = r2 << numDefine2;
                                r2 = (r9 + r2) | 0;
                                r2 = r2 >> numDefine2;
                                r9 = r7 >> numDefine2;
                                f1 = heapClassInst.heapFloat[r2];
                                f2 = heapClassInst.heapFloat[r9];
                                f3 = heapClassInst.heapFloat[r2 + numDefine4];
                                f4 = heapClassInst.heapFloat[r9 + 1];
                                f5 = heapClassInst.heapFloat[r2 + 1];
                                f6 = heapClassInst.heapFloat[r2 + numDefine5];
                                f7 = f1 * f2;
                                f8 = f3 * f4;
                                f9 = heapClassInst.heapFloat[r2 + numDefine8];
                                f10 = heapClassInst.heapFloat[r9 + numDefine2];
                                f11 = heapClassInst.heapFloat[r9 + numDefine8];
                                f12 = heapClassInst.heapFloat[r2 + numDefine2];
                                f13 = heapClassInst.heapFloat[r9 + numDefine4];
                                f14 = heapClassInst.heapFloat[r2 + numDefine12];
                                f15 = heapClassInst.heapFloat[r9 + numDefine9];
                                f16 = heapClassInst.heapFloat[r2 + numDefine6];
                                f17 = heapClassInst.heapFloat[r9 + numDefine5];
                                f18 = heapClassInst.heapFloat[r2 + numDefine13];
                                f19 = heapClassInst.heapFloat[r2 + numDefine9];
                                f20 = heapClassInst.heapFloat[r9 + numDefine10];
                                f21 = heapClassInst.heapFloat[r2 + numDefine10];
                                f22 = heapClassInst.heapFloat[r9 + numDefine6];
                                f23 = heapClassInst.heapFloat[r2 + numDefine14];
                                f24 = f5 * f2;
                                f25 = f6 * f4;
                                f7 = f7 + f8;
                                f8 = f9 * f10;
                                r2 = heapClassInst.heap32[r2 + numDefine16];
                                f26 = heapClassInst.heapFloat[r9 + numDefine14];
                                f27 = heapClassInst.heapFloat[r9 + numDefine13];
                                f28 = heapClassInst.heapFloat[r9 + numDefine12];
                                r9 = sp + numDefineNeg1408;
                                f29 = f12 * f2;
                                f30 = f16 * f4;
                                f24 = f24 + f25;
                                f25 = f19 * f10;
                                f7 = f7 + f8;
                                r10 = r9 >> numDefine2;
                                f8 = f29 + f30;
                                f29 = f21 * f10;
                                f24 = f24 + f25;
                                heapClassInst.heapFloat[fp + numDefineNeg352] = f7;
                                f7 = f1 * f13;
                                f25 = f3 * f17;
                                f8 = f8 + f29;
                                heapClassInst.heapFloat[r10 + 1] = f24;
                                heapClassInst.heapFloat[r10 + numDefine2] = f8;
                                f8 = f5 * f13;
                                f24 = f6 * f17;
                                f7 = f7 + f25;
                                f25 = f9 * f22;
                                f29 = f12 * f13;
                                f30 = f16 * f17;
                                f8 = f8 + f24;
                                f24 = f19 * f22;
                                f7 = f7 + f25;
                                heapClassInst.heap32[r10 + numDefine3] = 0;
                                f25 = f29 + f30;
                                f29 = f21 * f22;
                                f8 = f8 + f24;
                                heapClassInst.heapFloat[r10 + numDefine4] = f7;
                                f1 = f1 * f11;
                                f3 = f3 * f15;
                                f7 = f25 + f29;
                                heapClassInst.heapFloat[r10 + numDefine5] = f8;
                                heapClassInst.heapFloat[r10 + numDefine6] = f7;
                                f5 = f5 * f11;
                                f6 = f6 * f15;
                                f1 = f1 + f3;
                                f3 = f9 * f20;
                                f7 = f12 * f11;
                                f8 = f16 * f15;
                                f5 = f5 + f6;
                                f6 = f19 * f20;
                                f1 = f1 + f3;
                                heapClassInst.heap32[r10 + numDefine7] = 0;
                                f2 = f2 * f14;
                                f3 = f4 * f18;
                                f4 = f7 + f8;
                                f7 = f21 * f20;
                                f5 = f5 + f6;
                                heapClassInst.heapFloat[r10 + numDefine8] = f1;
                                f1 = f13 * f14;
                                f6 = f17 * f18;
                                f2 = f2 + f3;
                                f3 = f10 * f23;
                                f4 = f4 + f7;
                                heapClassInst.heapFloat[r10 + numDefine9] = f5;
                                f2 = f2 + f3;
                                heapClassInst.heapFloat[r10 + numDefine10] = f4;
                                f3 = f11 * f14;
                                f4 = f15 * f18;
                                f1 = f1 + f6;
                                f5 = f22 * f23;
                                f1 = f1 + f5;
                                f3 = f3 + f4;
                                f4 = f20 * f23;
                                f2 = f2 + f28;
                                heapClassInst.heap32[r10 + numDefine11] = 0;
                                f3 = f3 + f4;
                                f1 = f1 + f27;
                                heapClassInst.heapFloat[r10 + numDefine12] = f2;
                                f2 = f3 + f26;
                                heapClassInst.heapFloat[r10 + numDefine13] = f1;
                                heapClassInst.heapFloat[r10 + numDefine14] = f2;
                                r11 = r6 >> numDefine2;
                                heapClassInst.heap32[r10 + numDefine15] = 0;
                                r10 = heapClassInst.heap32[r11 + numDefine48];
                                r12 = 1;
                                heapClassInst.heap32[r11 + numDefine48] = r2;
                                r13 = ztvzn16CollsionQuerySingObjectPK;
                                r14 = -1;
                                heapClassInst.heap16[(sp + numDefineNeg1424) >> 1] = (short) r12;
                                r12 = sp + numDefineNeg1432;
                                heapClassInst.heap16[(sp + numDefineNeg1422) >> 1] = (short) r14;
                                r13 = (r13 + numDefine8) | 0;
                                r14 = r12 >> numDefine2;
                                heapClassInst.heap32[fp + numDefineNeg358] = r13;
                                heapClassInst.heap32[r14 + numDefine3] = r8;
                                r15 = r8 >> numDefine2;
                                heapClassInst.heap32[r14 + numDefine4] = r0;
                                heapClassInst.heap32[r14 + 1] = heapClassInst.heap32[r15 + 1];
                                heapClassInst.heap32[g0] = r3;
                                heapClassInst.heap32[g0 + 1] = r4;
                                heapClassInst.heap32[g0 + numDefine2] = r5;
                                heapClassInst.heap32[g0 + numDefine3] = r6;
                                heapClassInst.heap32[g0 + numDefine4] = r2;
                                heapClassInst.heap32[g0 + numDefine5] = r9;
                                heapClassInst.heap32[g0 + numDefine6] = r12;
                                heapClassInst.heapFloat[g0 + numDefine7] = f0;
                                zn16btCollisionWorld17objectQuerySingleEPK13btConvexShapeRK11btTransformS5P17btCollisionObjectPK16btCollisionShapeS5RNS20ConvexResultCallbackEf(i7);
                                r0 = (r0 + 1) | 0;
                                heapClassInst.heap32[r11 + numDefine48] = r10;
                                heapClassInst.heap32[fp + numDefineNeg358] = r13;
                                r2 = heapClassInst.heap32[r1 + numDefine4];
                                if (!(r2 > r0)) {
                                    break repeat8;
                                }
                            }
                        }
                        r0 = zn15CProfileManager11CurrentNodeE;
                        r0 = r0 >> numDefine2;
                        r1 = heapClassInst.heap32[r0];
                        r2 = r1 >> numDefine2;
                        r3 = heapClassInst.heap32[r2 + numDefine4];
                        r3 = (r3 + -1) | 0;
                        heapClassInst.heap32[r2 + numDefine4] = r3;
                        if (r3 != 0) {
                            break repeat1;
                        } else {
                            r3 = heapClassInst.heap32[r2 + 1];
                            if (r3 != 0) {
                                r1 = sp + numDefineNeg24;
                                heapClassInst.heap32[g0] = r1;
                                heapClassInst.heap32[g0 + 1] = 0;
                                r3 = zl13gProfileClock2E0;
                                getTimeOfDay(i7);
                                r3 = r3 >> numDefine2;
                                r3 = heapClassInst.heap32[r3];
                                r3 = r3 >> numDefine2;
                                r1 = r1 >> numDefine2;
                                r4 = heapClassInst.heap32[fp + numDefineNeg6];
                                r5 = heapClassInst.heap32[r3];
                                r4 = (r4 - r5) | 0;
                                r1 = heapClassInst.heap32[r1 + 1];
                                r3 = heapClassInst.heap32[r3 + 1];
                                r1 = (r1 - r3) | 0;
                                r3 = (int) ((r4 * numDefineN6) | 0);
                                r1 = (r1 + r3) | 0;
                                r3 = heapClassInst.heap32[r2 + numDefine3];
                                r1 = (r1 - r3) | 0;
                                f0 = r1 & 0xFFFFFFFFL;
                                f1 = numDefine1000;
                                f2 = heapClassInst.heapFloat[r2 + numDefine2];
                                f0 = f0 / f1;
                                f0 = f2 + f0;
                                heapClassInst.heapFloat[r2 + numDefine2] = f0;
                                r1 = heapClassInst.heap32[r2 + numDefine4];
                                if (r1 != 0) {
                                    break repeat1;
                                } else {
                                    r1 = heapClassInst.heap32[r0];
                                }
                            }
                            r1 = r1 >> numDefine2;
                            r1 = heapClassInst.heap32[r1 + numDefine5];
                            heapClassInst.heap32[r0] = r1;
                            return;
                        }
                    }
                } else {
                    if (r2 != numDefine21) {
                        r2 = r5 >> numDefine2;
                        r9 = r7 >> numDefine2;
                        f0 = heapClassInst.heapFloat[r9];
                        f1 = heapClassInst.heapFloat[r2];
                        f2 = heapClassInst.heapFloat[r9 + numDefine4];
                        f3 = heapClassInst.heapFloat[r2 + numDefine4];
                        r10 = r4 >> numDefine2;
                        f4 = heapClassInst.heapFloat[r2 + 1];
                        f5 = heapClassInst.heapFloat[r2 + numDefine5];
                        f6 = f1 * f0;
                        f7 = f3 * f2;
                        f8 = heapClassInst.heapFloat[r9 + numDefine8];
                        f9 = heapClassInst.heapFloat[r2 + numDefine8];
                        f10 = heapClassInst.heapFloat[r9 + numDefine2];
                        f11 = heapClassInst.heapFloat[r2 + numDefine2];
                        f12 = heapClassInst.heapFloat[r9 + 1];
                        f13 = heapClassInst.heapFloat[r2 + numDefine12];
                        f14 = heapClassInst.heapFloat[r10 + numDefine12];
                        f15 = heapClassInst.heapFloat[r9 + numDefine6];
                        f16 = heapClassInst.heapFloat[r2 + numDefine6];
                        f17 = heapClassInst.heapFloat[r9 + numDefine5];
                        f18 = heapClassInst.heapFloat[r2 + numDefine13];
                        f19 = heapClassInst.heapFloat[r10 + numDefine13];
                        f20 = heapClassInst.heapFloat[r9 + numDefine13];
                        f21 = heapClassInst.heapFloat[r2 + numDefine10];
                        f22 = heapClassInst.heapFloat[r9 + numDefine10];
                        f23 = heapClassInst.heapFloat[r2 + numDefine9];
                        f24 = heapClassInst.heapFloat[r9 + numDefine9];
                        f25 = heapClassInst.heapFloat[r2 + numDefine14];
                        heapClassInst.heapFloat[fp + numDefineNeg360] = f25;
                        f26 = heapClassInst.heapFloat[r10 + numDefine14];
                        f27 = heapClassInst.heapFloat[r9 + numDefine14];
                        f28 = heapClassInst.heapFloat[r9 + numDefine12];
                        heapClassInst.heapFloat[fp + numDefineNeg359] = f28;
                        f29 = f4 * f0;
                        f30 = f5 * f2;
                        f6 = f6 + f7;
                        f7 = f9 * f8;
                        r2 = sp + numDefineNeg1056;
                        f25 = f11 * f0;
                        f28 = f16 * f2;
                        f29 = f29 + f30;
                        f30 = f23 * f8;
                        f6 = f6 + f7;
                        r9 = r2 >> numDefine2;
                        f7 = f25 + f28;
                        f25 = f21 * f8;
                        f28 = f29 + f30;
                        heapClassInst.heapFloat[fp + numDefineNeg264] = f6;
                        f6 = f1 * f12;
                        f29 = f3 * f17;
                        f7 = f7 + f25;
                        heapClassInst.heapFloat[r9 + 1] = f28;
                        heapClassInst.heapFloat[r9 + numDefine2] = f7;
                        f7 = f4 * f12;
                        f25 = f5 * f17;
                        f6 = f6 + f29;
                        f28 = f9 * f24;
                        f29 = f11 * f12;
                        f30 = f16 * f17;
                        f7 = f7 + f25;
                        f25 = f23 * f24;
                        f6 = f6 + f28;
                        heapClassInst.heap32[r9 + numDefine3] = 0;
                        f28 = f29 + f30;
                        f29 = f21 * f24;
                        f7 = f7 + f25;
                        heapClassInst.heapFloat[r9 + numDefine4] = f6;
                        f1 = f1 * f10;
                        f3 = f3 * f15;
                        f6 = f28 + f29;
                        heapClassInst.heapFloat[r9 + numDefine5] = f7;
                        heapClassInst.heapFloat[r9 + numDefine6] = f6;
                        f4 = f4 * f10;
                        f5 = f5 * f15;
                        f1 = f1 + f3;
                        f3 = f9 * f22;
                        f6 = f11 * f10;
                        f7 = f16 * f15;
                        f4 = f4 + f5;
                        f5 = f23 * f22;
                        f1 = f1 + f3;
                        heapClassInst.heap32[r9 + numDefine7] = 0;
                        f3 = f6 + f7;
                        f6 = f21 * f22;
                        f4 = f4 + f5;
                        heapClassInst.heapFloat[r9 + numDefine8] = f1;
                        f1 = f3 + f6;
                        heapClassInst.heapFloat[r9 + numDefine9] = f4;
                        heapClassInst.heapFloat[r9 + numDefine10] = f1;
                        heapClassInst.heap32[r9 + numDefine11] = 0;
                        heapClassInst.heap32[r9 + numDefine12] = 0;
                        heapClassInst.heap32[r9 + numDefine13] = 0;
                        heapClassInst.heap32[r9 + numDefine14] = 0;
                        heapClassInst.heap32[r9 + numDefine15] = 0;
                        r9 = heapClassInst.heap32[r1];
                        r9 = r9 >> numDefine2;
                        r9 = heapClassInst.heap32[r9 + numDefine11];
                        heapClassInst.heap32[g0] = r0;
                        functionTable.get(r9 >> numDefine2).accept(i7);
                        r9 = sp + numDefineNeg1280;
                        heapClassInst.heap32[g0] = r9;
                        heapClassInst.heap32[g0 + 1] = r3;
                        heapClassInst.heap32[g0 + numDefine2] = r4;
                        heapClassInst.heap32[g0 + numDefine3] = r5;
                        heapClassInst.heap32[g0 + numDefine4] = r7;
                        heapClassInst.heapFloat[g0 + numDefine5] = (float) commonVariable.fg0;
                        r4 = ztvzn16CollsionQuerySingConvex;
                        zn28btTriangleConvexcastCallbackC2EPK13btConvexShapeRK11btTransformS5S5F(i7);
                        r4 = (r4 + numDefine8) | 0;
                        r5 = r9 >> numDefine2;
                        heapClassInst.heap32[fp + numDefineNeg320] = r4;
                        heapClassInst.heap32[r5 + numDefine52] = r8;
                        heapClassInst.heap32[r5 + numDefine53] = r6;
                        r4 = r8 >> numDefine2;
                        heapClassInst.heap32[r5 + numDefine54] = r0;
                        r6 = r3 >> numDefine2;
                        heapClassInst.heap32[r5 + numDefine50] = heapClassInst.heap32[r4 + 1];
                        r4 = heapClassInst.heap32[r6];
                        r4 = r4 >> numDefine2;
                        r4 = heapClassInst.heap32[r4 + numDefine2];
                        f28 = heapClassInst.heapFloat[fp + numDefineNeg359];
                        f1 = -f28;
                        r5 = sp + numDefineNeg1296;
                        r6 = sp + numDefineNeg1312;
                        f3 = f0 * f14;
                        f4 = f2 * f19;
                        f5 = f0 * f1;
                        f6 = f2 * f20;
                        f3 = f3 + f4;
                        f4 = f8 * f26;
                        f5 = f5 - f6;
                        f6 = f8 * f27;
                        heapClassInst.heap32[g0] = r3;
                        heapClassInst.heap32[g0 + 1] = r2;
                        heapClassInst.heap32[g0 + numDefine2] = r5;
                        heapClassInst.heap32[g0 + numDefine3] = r6;
                        f7 = f12 * f14;
                        f9 = f17 * f19;
                        f11 = f12 * f1;
                        f16 = f17 * f20;
                        f3 = f3 + f4;
                        f4 = f5 - f6;
                        f5 = f10 * f14;
                        f6 = f15 * f19;
                        f1 = f10 * f1;
                        f14 = f15 * f20;
                        f7 = f7 + f9;
                        f9 = f24 * f26;
                        f11 = f11 - f16;
                        f16 = f24 * f27;
                        f3 = f3 + f4;
                        functionTable.get(r4 >> numDefine2).accept(i7);
                        r2 = sp + numDefineNeg1328;
                        f0 = f0 * f13;
                        f2 = f2 * f18;
                        f10 = f10 * f13;
                        f15 = f15 * f18;
                        f12 = f12 * f13;
                        f13 = f17 * f18;
                        f5 = f5 + f6;
                        f6 = f22 * f26;
                        f1 = f1 - f14;
                        f14 = f22 * f27;
                        f7 = f7 + f9;
                        f9 = f11 - f16;
                        f7 = f7 + f9;
                        f0 = f0 + f2;
                        f25 = heapClassInst.heapFloat[fp + numDefineNeg360];
                        f2 = f8 * f25;
                        f8 = f10 + f15;
                        f10 = f22 * f25;
                        f11 = f12 + f13;
                        f12 = f24 * f25;
                        r3 = r2 >> numDefine2;
                        heapClassInst.heapFloat[fp + numDefineNeg332] = f3;
                        f5 = f5 + f6;
                        f1 = f1 - f14;
                        f0 = f0 + f2;
                        f2 = f8 + f10;
                        f6 = f11 + f12;
                        f5 = f5 + f1;
                        heapClassInst.heapFloat[r3 + 1] = f7;
                        f0 = f0 + f4;
                        f1 = f2 + f1;
                        f2 = f6 + f9;
                        heapClassInst.heapFloat[r3 + numDefine2] = f5;
                        heapClassInst.heap32[r3 + numDefine3] = 0;
                        if (f0 < f3) {
                            heapClassInst.heapFloat[fp + numDefineNeg332] = f0;
                            f4 = f0;
                        } else {
                            f4 = f3;
                        }
                        if (f2 < f7) {
                            heapClassInst.heapFloat[r3 + 1] = f2;
                            f6 = f2;
                        } else {
                            f6 = f7;
                        }
                        if (f1 < f5) {
                            heapClassInst.heapFloat[r3 + numDefine2] = f1;
                            f8 = f1;
                        } else {
                            f8 = f5;
                        }
                        r4 = sp + numDefineNeg1344;
                        r7 = r4 >> numDefine2;
                        heapClassInst.heapFloat[fp + numDefineNeg336] = f3;
                        heapClassInst.heapFloat[r7 + 1] = f7;
                        heapClassInst.heapFloat[r7 + numDefine2] = f5;
                        heapClassInst.heap32[r7 + numDefine3] = 0;
                        if (f3 < f0) {
                            heapClassInst.heapFloat[fp + numDefineNeg336] = f0;
                            f3 = f0;
                        }
                        if (f7 < f2) {
                            heapClassInst.heapFloat[r7 + 1] = f2;
                            f7 = f2;
                        }
                        if (f5 < f1) {
                            heapClassInst.heapFloat[r7 + numDefine2] = f1;
                            f5 = f1;
                        }
                        f0 = heapClassInst.heapFloat[fp + numDefineNeg324];
                        f0 = f4 + f0;
                        r5 = r5 >> numDefine2;
                        heapClassInst.heapFloat[fp + numDefineNeg332] = f0;
                        f0 = heapClassInst.heapFloat[r5 + 1];
                        f0 = f6 + f0;
                        heapClassInst.heapFloat[r3 + 1] = f0;
                        f0 = heapClassInst.heapFloat[r5 + numDefine2];
                        f0 = f8 + f0;
                        heapClassInst.heapFloat[r3 + numDefine2] = f0;
                        f0 = heapClassInst.heapFloat[fp + numDefineNeg328];
                        f0 = f3 + f0;
                        r3 = r6 >> numDefine2;
                        heapClassInst.heapFloat[fp + numDefineNeg336] = f0;
                        f0 = heapClassInst.heapFloat[r3 + 1];
                        f0 = f7 + f0;
                        heapClassInst.heapFloat[r7 + 1] = f0;
                        f0 = heapClassInst.heapFloat[r3 + numDefine2];
                        f0 = f5 + f0;
                        heapClassInst.heapFloat[r7 + numDefine2] = f0;
                        r1 = heapClassInst.heap32[r1];
                        r1 = r1 >> numDefine2;
                        r1 = heapClassInst.heap32[r1 + numDefine15];
                        heapClassInst.heap32[g0] = r0;
                        heapClassInst.heap32[g0 + 1] = r9;
                        heapClassInst.heap32[g0 + numDefine2] = r2;
                        heapClassInst.heap32[g0 + numDefine3] = r4;
                        functionTable.get(r1 >> numDefine2).accept(i7);
                        return;
                    } else {
                        r2 = r7 >> numDefine2;
                        r9 = r4 >> numDefine2;
                        f0 = heapClassInst.heapFloat[r2 + numDefine12];
                        f0 = -f0;
                        f1 = heapClassInst.heapFloat[r2];
                        f2 = heapClassInst.heapFloat[r9 + numDefine12];
                        f3 = heapClassInst.heapFloat[r2 + numDefine4];
                        f4 = heapClassInst.heapFloat[r2 + numDefine13];
                        f5 = heapClassInst.heapFloat[r9 + numDefine13];
                        f6 = heapClassInst.heapFloat[r2 + 1];
                        f7 = heapClassInst.heapFloat[r2 + numDefine5];
                        f8 = f1 * f2;
                        f9 = f3 * f5;
                        f10 = f1 * f0;
                        f11 = f3 * f4;
                        f12 = heapClassInst.heapFloat[r2 + numDefine8];
                        f13 = heapClassInst.heapFloat[r2 + numDefine14];
                        f14 = heapClassInst.heapFloat[r9 + numDefine14];
                        f15 = heapClassInst.heapFloat[r2 + numDefine9];
                        f16 = heapClassInst.heapFloat[r2 + numDefine2];
                        f17 = heapClassInst.heapFloat[r2 + numDefine6];
                        f18 = f6 * f2;
                        f19 = f7 * f5;
                        f20 = f6 * f0;
                        f21 = f7 * f4;
                        f8 = f8 + f9;
                        f9 = f12 * f14;
                        f10 = f10 - f11;
                        f11 = f12 * f13;
                        f22 = heapClassInst.heapFloat[r2 + numDefine10];
                        f2 = f16 * f2;
                        f5 = f17 * f5;
                        f0 = f16 * f0;
                        f4 = f17 * f4;
                        f18 = f18 + f19;
                        f19 = f15 * f14;
                        f20 = f20 - f21;
                        f21 = f15 * f13;
                        f8 = f8 + f9;
                        f9 = f10 - f11;
                        r2 = sp + numDefineNeg656;
                        f2 = f2 + f5;
                        f5 = f22 * f14;
                        f0 = f0 - f4;
                        f4 = f22 * f13;
                        f10 = f18 + f19;
                        f11 = f20 - f21;
                        f8 = f8 + f9;
                        r9 = r2 >> numDefine2;
                        f2 = f2 + f5;
                        f0 = f0 - f4;
                        f4 = f10 + f11;
                        heapClassInst.heapFloat[fp + numDefineNeg164] = f8;
                        f2 = f2 + f0;
                        heapClassInst.heapFloat[r9 + 1] = f4;
                        heapClassInst.heapFloat[r9 + numDefine2] = f2;
                        r10 = r5 >> numDefine2;
                        heapClassInst.heap32[r9 + numDefine3] = 0;
                        f2 = heapClassInst.heapFloat[r10 + numDefine12];
                        f4 = heapClassInst.heapFloat[r10 + numDefine13];
                        f5 = heapClassInst.heapFloat[r10 + numDefine14];
                        f8 = f1 * f2;
                        f10 = f3 * f4;
                        f13 = f6 * f2;
                        f14 = f7 * f4;
                        f8 = f8 + f10;
                        f10 = f12 * f5;
                        f8 = f8 + f10;
                        f2 = f16 * f2;
                        f4 = f17 * f4;
                        f10 = f13 + f14;
                        f13 = f15 * f5;
                        r9 = sp + numDefineNeg672;
                        f10 = f10 + f13;
                        f2 = f2 + f4;
                        f4 = f22 * f5;
                        f5 = f8 + f9;
                        f2 = f2 + f4;
                        r11 = r9 >> numDefine2;
                        f4 = f10 + f11;
                        heapClassInst.heapFloat[fp + numDefineNeg168] = f5;
                        f0 = f2 + f0;
                        heapClassInst.heapFloat[r11 + 1] = f4;
                        heapClassInst.heapFloat[r11 + numDefine2] = f0;
                        heapClassInst.heap32[r11 + numDefine3] = 0;
                        f0 = heapClassInst.heapFloat[r10];
                        f2 = heapClassInst.heapFloat[r10 + numDefine4];
                        f4 = heapClassInst.heapFloat[r10 + 1];
                        f5 = heapClassInst.heapFloat[r10 + numDefine5];
                        f8 = heapClassInst.heapFloat[r10 + numDefine8];
                        f9 = f0 * f1;
                        f10 = f2 * f3;
                        f11 = heapClassInst.heapFloat[r10 + numDefine2];
                        f13 = heapClassInst.heapFloat[r10 + numDefine6];
                        f14 = heapClassInst.heapFloat[r10 + numDefine10];
                        f18 = heapClassInst.heapFloat[r10 + numDefine9];
                        f19 = f4 * f1;
                        f20 = f5 * f3;
                        f9 = f9 + f10;
                        f10 = f8 * f12;
                        r10 = sp + numDefineNeg736;
                        f1 = f11 * f1;
                        f3 = f13 * f3;
                        f19 = f19 + f20;
                        f20 = f18 * f12;
                        f9 = f9 + f10;
                        r11 = r10 >> numDefine2;
                        f1 = f1 + f3;
                        f3 = f14 * f12;
                        f10 = f19 + f20;
                        heapClassInst.heapFloat[fp + numDefineNeg184] = f9;
                        f9 = f0 * f6;
                        f12 = f2 * f7;
                        f1 = f1 + f3;
                        heapClassInst.heapFloat[r11 + 1] = f10;
                        heapClassInst.heapFloat[r11 + numDefine2] = f1;
                        f1 = f4 * f6;
                        f3 = f5 * f7;
                        f9 = f9 + f12;
                        f10 = f8 * f15;
                        f6 = f11 * f6;
                        f7 = f13 * f7;
                        f1 = f1 + f3;
                        f3 = f18 * f15;
                        f9 = f9 + f10;
                        heapClassInst.heap32[r11 + numDefine3] = 0;
                        f6 = f6 + f7;
                        f7 = f14 * f15;
                        f1 = f1 + f3;
                        heapClassInst.heapFloat[r11 + numDefine4] = f9;
                        f0 = f0 * f16;
                        f2 = f2 * f17;
                        f3 = f6 + f7;
                        heapClassInst.heapFloat[r11 + numDefine5] = f1;
                        heapClassInst.heapFloat[r11 + numDefine6] = f3;
                        f1 = f4 * f16;
                        f3 = f5 * f17;
                        f0 = f0 + f2;
                        f2 = f8 * f22;
                        f4 = f11 * f16;
                        f5 = f13 * f17;
                        f1 = f1 + f3;
                        f3 = f18 * f22;
                        f0 = f0 + f2;
                        heapClassInst.heap32[r11 + numDefine7] = 0;
                        f2 = f4 + f5;
                        f4 = f14 * f22;
                        f1 = f1 + f3;
                        heapClassInst.heapFloat[r11 + numDefine8] = f0;
                        f0 = f2 + f4;
                        heapClassInst.heapFloat[r11 + numDefine9] = f1;
                        heapClassInst.heapFloat[r11 + numDefine10] = f0;
                        heapClassInst.heap32[r11 + numDefine11] = 0;
                        heapClassInst.heap32[r11 + numDefine12] = 0;
                        heapClassInst.heap32[r11 + numDefine13] = 0;
                        heapClassInst.heap32[r11 + numDefine14] = 0;
                        heapClassInst.heap32[r11 + numDefine15] = 0;
                        r11 = heapClassInst.heap32[r1];
                        r11 = r11 >> numDefine2;
                        r11 = heapClassInst.heap32[r11 + numDefine11];
                        heapClassInst.heap32[g0] = r0;
                        functionTable.get(r11 >> numDefine2).accept(i7);
                        r11 = sp + numDefineNeg960;
                        heapClassInst.heap32[g0] = r11;
                        heapClassInst.heap32[g0 + 1] = r3;
                        heapClassInst.heap32[g0 + numDefine2] = r4;
                        heapClassInst.heap32[g0 + numDefine3] = r5;
                        heapClassInst.heap32[g0 + numDefine4] = r7;
                        heapClassInst.heapFloat[g0 + numDefine5] = (float) commonVariable.fg0;
                        r4 = ztvzn16CollsionQuery;
                        zn28btTriangleConvexcastCallbackC2EPK13btConvexShapeRK11btTransformS5S5F(i7);
                        r4 = (r4 + numDefine8) | 0;
                        r5 = r11 >> numDefine2;
                        heapClassInst.heap32[fp + numDefineNeg240] = r4;
                        heapClassInst.heap32[r5 + numDefine52] = r8;
                        heapClassInst.heap32[r5 + numDefine53] = r6;
                        r4 = r8 >> numDefine2;
                        heapClassInst.heap32[r5 + numDefine54] = r0;
                        r0 = r3 >> numDefine2;
                        heapClassInst.heap32[r5 + numDefine50] = heapClassInst.heap32[r4 + 1];
                        r0 = heapClassInst.heap32[r0];
                        r0 = r0 >> numDefine2;
                        r0 = heapClassInst.heap32[r0 + numDefine2];
                        r4 = sp + numDefineNeg976;
                        r5 = sp + numDefineNeg992;
                        heapClassInst.heap32[g0] = r3;
                        heapClassInst.heap32[g0 + 1] = r10;
                        heapClassInst.heap32[g0 + numDefine2] = r4;
                        heapClassInst.heap32[g0 + numDefine3] = r5;
                        functionTable.get(r0 >> numDefine2).accept(i7);
                        r0 = ztvzn22btBvhTriangleMeshShape17performConvexcastEP18btTriangleCallbackRK9btVector3S4S4S4E21MyNodeOverlapCallback;
                        r3 = sp + numDefineNeg16;
                        r6 = heapClassInst.heap32[r1 + numDefine12];
                        r0 = (r0 + numDefine8) | 0;
                        r7 = r3 >> numDefine2;
                        heapClassInst.heap32[fp + numDefineNeg4] = r0;
                        heapClassInst.heap32[r7 + 1] = r6;
                        heapClassInst.heap32[r7 + numDefine2] = r11;
                        r0 = heapClassInst.heap32[r1 + numDefine13];
                        r1 = heapClassInst.heapU8[r0 + numDefine60];
                        if (r1 == 0) {
                            heapClassInst.heap32[g0] = r0;
                            heapClassInst.heap32[g0 + 1] = r3;
                            heapClassInst.heap32[g0 + numDefine2] = r2;
                            heapClassInst.heap32[g0 + numDefine3] = r9;
                            heapClassInst.heap32[g0 + numDefine4] = r4;
                            heapClassInst.heap32[g0 + numDefine5] = r5;
                            znk14btQuantizedBvh27walkStacklessTreeAgainstRayEP21btNodeOverlapCallbackRK9btVector3S4S4S4Ii(i7);
                            return;
                        } else {
                            r1 = r0 >> numDefine2;
                            r1 = heapClassInst.heap32[r1 + numDefine14];
                            heapClassInst.heap32[g0] = r0;
                            heapClassInst.heap32[g0 + 1] = r3;
                            heapClassInst.heap32[g0 + numDefine2] = r2;
                            heapClassInst.heap32[g0 + numDefine3] = r9;
                            heapClassInst.heap32[g0 + numDefine4] = r4;
                            heapClassInst.heap32[g0 + numDefine5] = r5;
                            heapClassInst.heap32[g0 + numDefine6] = r1;
                            znk14btQuantizedBvh36walkStacklessQuantizedTreeAgainstRayEP21btNodeOverlapCallbackRK9btVector3S4S4S4Ii(i7);
                            return;
                        }
                    }
                }
            } else {
                r1 = ztvn12btConvexCast10CastResultE;
                r2 = sp + numDefineNeg200;
                r1 = (r1 + numDefine8) | 0;
                r9 = r2 >> numDefine2;
                heapClassInst.heap32[fp + numDefineNeg50] = r1;
                heapClassInst.heap32[r9 + numDefine42] = 0;
                r1 = sp + numDefineNeg560;
                r10 = r8 >> numDefine2;
                heapClassInst.heapFloat[r9 + numDefine43] = f0;
                r11 = r1 >> numDefine2;
                heapClassInst.heap32[r9 + numDefine41] = heapClassInst.heap32[r10 + 1];
                r12 = ztv30btGjkEpaPenetrationDepthSolver;
                r13 = 0;
                heapClassInst.heap32[r11 + numDefine77] = numDefine67991;
                r11 = ztv27btContinuousConvexCollision;
                r12 = (r12 + numDefine8) | 0;
                heapClassInst.heap8[sp + numDefineNeg228] = (byte) r13;
                r13 = sp + numDefineNeg592;
                r11 = (r11 + numDefine8) | 0;
                heapClassInst.heap32[fp + numDefineNeg142] = r12;
                r12 = r13 >> numDefine2;
                heapClassInst.heap32[fp + numDefineNeg148] = r11;
                r11 = sp + numDefineNeg568;
                heapClassInst.heap32[r12 + 1] = r1;
                heapClassInst.heap32[r12 + numDefine2] = r11;
                heapClassInst.heap32[r12 + numDefine3] = r3;
                heapClassInst.heap32[r12 + numDefine4] = r0;
                heapClassInst.heap32[g0] = r13;
                heapClassInst.heap32[g0 + 1] = r4;
                heapClassInst.heap32[g0 + numDefine2] = r5;
                heapClassInst.heap32[g0 + numDefine3] = r7;
                heapClassInst.heap32[g0 + numDefine4] = r7;
                heapClassInst.heap32[g0 + numDefine5] = r2;
                zn27btContinuousConvexCollisionTransformConvexCast10CastResultE(i7);
                r0 = commonVariable.rg0;
                if (!(r0 == 0)) {
                    f0 = heapClassInst.heapFloat[r9 + numDefine33];
                    f1 = heapClassInst.heapFloat[r9 + numDefine34];
                    f2 = heapClassInst.heapFloat[r9 + numDefine35];
                    f0 = f0 * f0;
                    f1 = f1 * f1;
                    f0 = f0 + f1;
                    f1 = f2 * f2;
                    f0 = f0 + f1;
                    f1 = (float) numDefineFloat9165;
                    if (!(f0 <= f1)) {
                        f1 = heapClassInst.heapFloat[r9 + numDefine41];
                        f2 = heapClassInst.heapFloat[r10 + 1];
                        if (!(f1 >= f2)) {
                            heapClassInst.heapFloat[g0] = f0;
                            sqrtf(i7);
                            f1 = 1;
                            f2 = heapClassInst.heapFloat[r9 + numDefine33];
                            f0 = (float) (f1 / commonVariable.fg0);
                            f1 = f2 * f0;
                            heapClassInst.heapFloat[r9 + numDefine33] = f1;
                            f2 = heapClassInst.heapFloat[r9 + numDefine34];
                            f2 = f2 * f0;
                            heapClassInst.heapFloat[r9 + numDefine34] = f2;
                            f3 = heapClassInst.heapFloat[r9 + numDefine35];
                            f0 = f3 * f0;
                            heapClassInst.heapFloat[r9 + numDefine35] = f0;
                            r0 = sp + numDefineNeg640;
                            f3 = heapClassInst.heapFloat[r9 + numDefine41];
                            r1 = r0 >> numDefine2;
                            heapClassInst.heap32[fp + numDefineNeg160] = r6;
                            heapClassInst.heap32[r1 + 1] = 0;
                            heapClassInst.heapFloat[r1 + numDefine2] = f1;
                            heapClassInst.heapFloat[r1 + numDefine3] = f2;
                            heapClassInst.heapFloat[r1 + numDefine4] = f0;
                            heapClassInst.heap32[r1 + numDefine5] = heapClassInst.heap32[r9 + numDefine36];
                            heapClassInst.heap32[r1 + numDefine6] = heapClassInst.heap32[r9 + numDefine37];
                            heapClassInst.heap32[r1 + numDefine7] = heapClassInst.heap32[r9 + numDefine38];
                            heapClassInst.heap32[r1 + numDefine8] = heapClassInst.heap32[r9 + numDefine39];
                            heapClassInst.heap32[r1 + numDefine9] = heapClassInst.heap32[r9 + numDefine40];
                            heapClassInst.heapFloat[r1 + numDefine10] = f3;
                            r1 = heapClassInst.heap32[r10];
                            r1 = r1 >> numDefine2;
                            r1 = heapClassInst.heap32[r1 + numDefine3];
                            heapClassInst.heap32[g0] = r8;
                            heapClassInst.heap32[g0 + 1] = r0;
                            heapClassInst.heap32[g0 + numDefine2] = 1;
                            functionTable.get(r1 >> numDefine2).accept(i7);
                        }
                    }
                }
            }
        } while (false);
        return;
    }

    public static void zn16btCollisionWorld13rayTestSingleERK11btTransformS2P17btCollisionObjectPK16btCollisionShapeS2RNS17RayResultCallbackE(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        int r6 = 0;
        int r7 = 0;
        int r8 = 0;
        int r9 = 0;
        int r10 = 0;
        int r11 = 0;
        int r12 = 0;
        int r13 = 0;
        int r14 = 0;
        float f0 = 0.0F;
        float f1 = 0.0F;
        float f2 = 0.0F;
        float f3 = 0.0F;
        float f4 = 0.0F;
        float f5 = 0.0F;
        float f6 = 0.0F;
        float f7 = 0.0F;
        float f8 = 0.0F;
        float f9 = 0.0F;
        float f10 = 0.0F;
        float f11 = 0.0F;
        float f12 = 0.0F;
        float f13 = 0.0F;
        float f14 = 0.0F;
        float f15 = 0.0F;
        float f16 = 0.0F;
        float f17 = 0.0F;
        float f18 = 0.0F;
        float f19 = 0.0F;
        float f20 = 0.0F;
        float f21 = 0.0F;
        float f22 = 0.0F;
        float f23 = 0.0F;
        float f24 = 0.0F;
        float f25 = 0.0F;
        float f26 = 0.0F;
        float f27 = 0.0F;
        float f28 = 0.0F;
        float f29 = 0.0F;
        int label = 0;
        i7 = sp + numDefineNeg1120;
        int g0 = i7 >> numDefine2;
        r0 = sp + numDefineNeg104;
        r1 = r0 >> numDefine2;
        heapClassInst.heap32[r1 + numDefine2] = 0;
        heapClassInst.heap32[r1 + numDefine3] = numDefine53216;
        heapClassInst.heap32[r1 + numDefine4] = numDefine53216;
        r2 = ztv13btSphereShape;
        heapClassInst.heap32[r1 + numDefine5] = numDefine53216;
        r2 = (r2 + numDefine8) | 0;
        heapClassInst.heap32[r1 + numDefine6] = 0;
        heapClassInst.heap32[fp + numDefineNeg26] = r2;
        heapClassInst.heap32[r1 + 1] = numDefine8;
        r2 = heapClassInst.heap32[fp + numDefine3];
        heapClassInst.heap32[r1 + numDefine7] = 0;
        r3 = r2 >> numDefine2;
        heapClassInst.heap32[r1 + numDefine11] = 0;
        r1 = heapClassInst.heap32[r3 + 1];
        r4 = heapClassInst.heap32[fp];
        r5 = heapClassInst.heap32[fp + 1];
        r6 = heapClassInst.heap32[fp + numDefine2];
        r7 = heapClassInst.heap32[fp + numDefine4];
        r8 = heapClassInst.heap32[fp + numDefine5];
        if (r1 > numDefine19) {
            r0 = (r1 + numDefineNeg21) | 0;
            if ((r0 & 0xFFFFFFFFL) > (numDefine8 & 0xFFFFFFFFL)) {
                if (!(r1 != numDefine31)) {
                    r0 = heapClassInst.heap32[r3 + numDefine4];
                    if (!(r0 < 1)) {
                        r0 = 0;
                        repeat8:
                        while (true) {
                            r1 = (r0 * numDefine20) | 0;
                            r2 = heapClassInst.heap32[r3 + numDefine6];
                            r1 = r1 << numDefine2;
                            r1 = (r2 + r1) | 0;
                            r1 = r1 >> numDefine2;
                            r2 = r7 >> numDefine2;
                            f0 = heapClassInst.heapFloat[r1];
                            f1 = heapClassInst.heapFloat[r2];
                            f2 = heapClassInst.heapFloat[r1 + numDefine4];
                            f3 = heapClassInst.heapFloat[r2 + 1];
                            f4 = heapClassInst.heapFloat[r1 + 1];
                            f5 = heapClassInst.heapFloat[r1 + numDefine5];
                            f6 = f0 * f1;
                            f7 = f2 * f3;
                            f8 = heapClassInst.heapFloat[r1 + numDefine8];
                            f9 = heapClassInst.heapFloat[r2 + numDefine2];
                            f10 = heapClassInst.heapFloat[r2 + numDefine8];
                            f11 = heapClassInst.heapFloat[r1 + numDefine2];
                            f12 = heapClassInst.heapFloat[r2 + numDefine4];
                            f13 = heapClassInst.heapFloat[r1 + numDefine12];
                            f14 = heapClassInst.heapFloat[r2 + numDefine9];
                            f15 = heapClassInst.heapFloat[r1 + numDefine6];
                            f16 = heapClassInst.heapFloat[r2 + numDefine5];
                            f17 = heapClassInst.heapFloat[r1 + numDefine13];
                            f18 = heapClassInst.heapFloat[r1 + numDefine9];
                            f19 = heapClassInst.heapFloat[r2 + numDefine10];
                            f20 = heapClassInst.heapFloat[r1 + numDefine10];
                            f21 = heapClassInst.heapFloat[r2 + numDefine6];
                            f22 = heapClassInst.heapFloat[r1 + numDefine14];
                            f23 = f4 * f1;
                            f24 = f5 * f3;
                            f6 = f6 + f7;
                            f7 = f8 * f9;
                            r1 = heapClassInst.heap32[r1 + numDefine16];
                            f25 = heapClassInst.heapFloat[r2 + numDefine14];
                            f26 = heapClassInst.heapFloat[r2 + numDefine13];
                            f27 = heapClassInst.heapFloat[r2 + numDefine12];
                            r2 = sp + numDefineNeg1056;
                            f28 = f11 * f1;
                            f29 = f15 * f3;
                            f23 = f23 + f24;
                            f24 = f18 * f9;
                            f6 = f6 + f7;
                            r9 = r2 >> numDefine2;
                            f7 = f28 + f29;
                            f28 = f20 * f9;
                            f23 = f23 + f24;
                            heapClassInst.heapFloat[fp + numDefineNeg264] = f6;
                            f6 = f0 * f12;
                            f24 = f2 * f16;
                            f7 = f7 + f28;
                            heapClassInst.heapFloat[r9 + 1] = f23;
                            heapClassInst.heapFloat[r9 + numDefine2] = f7;
                            f7 = f4 * f12;
                            f23 = f5 * f16;
                            f6 = f6 + f24;
                            f24 = f8 * f21;
                            f28 = f11 * f12;
                            f29 = f15 * f16;
                            f7 = f7 + f23;
                            f23 = f18 * f21;
                            f6 = f6 + f24;
                            heapClassInst.heap32[r9 + numDefine3] = 0;
                            f24 = f28 + f29;
                            f28 = f20 * f21;
                            f7 = f7 + f23;
                            heapClassInst.heapFloat[r9 + numDefine4] = f6;
                            f0 = f0 * f10;
                            f2 = f2 * f14;
                            f6 = f24 + f28;
                            heapClassInst.heapFloat[r9 + numDefine5] = f7;
                            heapClassInst.heapFloat[r9 + numDefine6] = f6;
                            f4 = f4 * f10;
                            f5 = f5 * f14;
                            f0 = f0 + f2;
                            f2 = f8 * f19;
                            f6 = f11 * f10;
                            f7 = f15 * f14;
                            f4 = f4 + f5;
                            f5 = f18 * f19;
                            f0 = f0 + f2;
                            heapClassInst.heap32[r9 + numDefine7] = 0;
                            f1 = f1 * f13;
                            f2 = f3 * f17;
                            f3 = f6 + f7;
                            f6 = f20 * f19;
                            f4 = f4 + f5;
                            heapClassInst.heapFloat[r9 + numDefine8] = f0;
                            f0 = f12 * f13;
                            f5 = f16 * f17;
                            f1 = f1 + f2;
                            f2 = f9 * f22;
                            f3 = f3 + f6;
                            heapClassInst.heapFloat[r9 + numDefine9] = f4;
                            f1 = f1 + f2;
                            heapClassInst.heapFloat[r9 + numDefine10] = f3;
                            f2 = f10 * f13;
                            f3 = f14 * f17;
                            f0 = f0 + f5;
                            f4 = f21 * f22;
                            f0 = f0 + f4;
                            f2 = f2 + f3;
                            f3 = f19 * f22;
                            f1 = f1 + f27;
                            heapClassInst.heap32[r9 + numDefine11] = 0;
                            f2 = f2 + f3;
                            f0 = f0 + f26;
                            heapClassInst.heapFloat[r9 + numDefine12] = f1;
                            f1 = f2 + f25;
                            heapClassInst.heapFloat[r9 + numDefine13] = f0;
                            heapClassInst.heapFloat[r9 + numDefine14] = f1;
                            r10 = r6 >> numDefine2;
                            heapClassInst.heap32[r9 + numDefine15] = 0;
                            r9 = sp + numDefineNeg1088;
                            r11 = heapClassInst.heap32[r10 + numDefine48];
                            r12 = r9 >> numDefine2;
                            heapClassInst.heap32[r10 + numDefine48] = r1;
                            r13 = 1;
                            heapClassInst.heap32[r12 + numDefine2] = 0;
                            r14 = -1;
                            heapClassInst.heap16[(sp + numDefineNeg1076) >> 1] = (short) r13;
                            heapClassInst.heap16[(sp + numDefineNeg1074) >> 1] = (short) r14;
                            r13 = ztvzn16btCollisionWorld13rayTestSingleERK11btTransformS2P17btCollisionObjectPK16btCollisionShapeS2RNS17RayResultCallbackEE15LocalInfoAdder2;
                            heapClassInst.heap32[r12 + numDefine4] = 0;
                            r13 = (r13 + numDefine8) | 0;
                            heapClassInst.heap32[fp + numDefineNeg272] = r13;
                            heapClassInst.heap32[r12 + numDefine5] = r8;
                            r14 = r8 >> numDefine2;
                            heapClassInst.heap32[r12 + numDefine6] = r0;
                            heapClassInst.heap32[r12 + 1] = heapClassInst.heap32[r14 + 1];
                            heapClassInst.heap32[g0] = r4;
                            heapClassInst.heap32[g0 + 1] = r5;
                            heapClassInst.heap32[g0 + numDefine2] = r6;
                            heapClassInst.heap32[g0 + numDefine3] = r1;
                            heapClassInst.heap32[g0 + numDefine4] = r2;
                            heapClassInst.heap32[g0 + numDefine5] = r9;
                            zn16btCollisionWorld13rayTestSingleERK11btTransformS2P17btCollisionObjectPK16btCollisionShapeS2RNS17RayResultCallbackE(i7);
                            r0 = (r0 + 1) | 0;
                            heapClassInst.heap32[r10 + numDefine48] = r11;
                            heapClassInst.heap32[fp + numDefineNeg272] = r13;
                            r1 = heapClassInst.heap32[r3 + numDefine4];
                            if (!(r1 > r0)) {
                                break repeat8;
                            }
                        }
                    }
                }
                return;
            } else {
                if (r1 != numDefine21) {
                    r1 = r7 >> numDefine2;
                    r4 = r4 >> numDefine2;
                    f0 = heapClassInst.heapFloat[r1 + numDefine12];
                    f1 = heapClassInst.heapFloat[r1 + numDefine13];
                    f2 = heapClassInst.heapFloat[r1 + numDefine4];
                    f3 = heapClassInst.heapFloat[r4 + numDefine13];
                    f4 = heapClassInst.heapFloat[r1];
                    f5 = -f0;
                    f6 = heapClassInst.heapFloat[r4 + numDefine12];
                    f7 = heapClassInst.heapFloat[r1 + numDefine5];
                    f8 = heapClassInst.heapFloat[r1 + 1];
                    f9 = f4 * f6;
                    f10 = f2 * f3;
                    f11 = f4 * f5;
                    f12 = f2 * f1;
                    f13 = heapClassInst.heapFloat[r1 + numDefine14];
                    f14 = heapClassInst.heapFloat[r1 + numDefine8];
                    f15 = heapClassInst.heapFloat[r4 + numDefine14];
                    r4 = r5 >> numDefine2;
                    f16 = heapClassInst.heapFloat[r1 + numDefine9];
                    f17 = heapClassInst.heapFloat[r1 + numDefine6];
                    f18 = heapClassInst.heapFloat[r1 + numDefine2];
                    r5 = r8 >> numDefine2;
                    f9 = f9 + f10;
                    f10 = f14 * f15;
                    f11 = f11 - f12;
                    f12 = f14 * f13;
                    f19 = f8 * f6;
                    f20 = f7 * f3;
                    f21 = f8 * f5;
                    f22 = f7 * f1;
                    f23 = heapClassInst.heapFloat[r4 + numDefine12];
                    f24 = heapClassInst.heapFloat[r4 + numDefine13];
                    f25 = heapClassInst.heapFloat[r1 + numDefine10];
                    f26 = heapClassInst.heapFloat[r4 + numDefine14];
                    r4 = sp + numDefineNeg960;
                    r7 = heapClassInst.heap32[r5 + numDefine4];
                    f9 = f9 + f10;
                    f10 = f11 - f12;
                    f6 = f18 * f6;
                    f3 = f17 * f3;
                    f11 = f19 + f20;
                    f12 = f16 * f15;
                    f5 = f18 * f5;
                    f19 = f17 * f1;
                    f20 = f21 - f22;
                    f21 = f16 * f13;
                    f9 = f9 + f10;
                    f3 = f6 + f3;
                    f6 = f25 * f15;
                    f11 = f11 + f12;
                    f12 = f20 - f21;
                    r0 = r4 >> numDefine2;
                    f5 = f5 - f19;
                    f15 = f25 * f13;
                    f11 = f11 + f12;
                    heapClassInst.heapFloat[r0 + 1] = f9;
                    f19 = f4 * f23;
                    f20 = f2 * f24;
                    f3 = f3 + f6;
                    f5 = f5 - f15;
                    f3 = f3 + f5;
                    heapClassInst.heapFloat[r0 + numDefine2] = f11;
                    f6 = f19 + f20;
                    f15 = f14 * f26;
                    f19 = f8 * f23;
                    f20 = f7 * f24;
                    f6 = f6 + f15;
                    heapClassInst.heapFloat[r0 + numDefine3] = f3;
                    f15 = f18 * f23;
                    f21 = f17 * f24;
                    f19 = f19 + f20;
                    f20 = f16 * f26;
                    f6 = f6 + f10;
                    f10 = f19 + f20;
                    heapClassInst.heap32[r0 + numDefine4] = 0;
                    f15 = f15 + f21;
                    f19 = f25 * f26;
                    f15 = f15 + f19;
                    f10 = f10 + f12;
                    heapClassInst.heapFloat[r0 + numDefine5] = f6;
                    f5 = f15 + f5;
                    heapClassInst.heapFloat[r0 + numDefine6] = f10;
                    heapClassInst.heapFloat[r0 + numDefine7] = f5;
                    r9 = ztvzn16CollsionTestCallback0;
                    heapClassInst.heap32[r0 + numDefine8] = 0;
                    r9 = (r9 + numDefine8) | 0;
                    heapClassInst.heap32[r0 + numDefine9] = r7;
                    heapClassInst.heap32[fp + numDefineNeg240] = r9;
                    heapClassInst.heap32[r0 + numDefine11] = r8;
                    heapClassInst.heap32[r0 + numDefine12] = r6;
                    heapClassInst.heap32[r0 + numDefine13] = r2;
                    heapClassInst.heapFloat[r0 + numDefine14] = f4;
                    heapClassInst.heapFloat[r0 + numDefine15] = f8;
                    heapClassInst.heapFloat[r0 + numDefine16] = f18;
                    heapClassInst.heap32[r0 + numDefine17] = heapClassInst.heap32[r1 + numDefine3];
                    heapClassInst.heapFloat[r0 + numDefine18] = f2;
                    heapClassInst.heapFloat[r0 + numDefine19] = f7;
                    heapClassInst.heapFloat[r0 + numDefine20] = f17;
                    heapClassInst.heap32[r0 + numDefine21] = heapClassInst.heap32[r1 + numDefine7];
                    heapClassInst.heapFloat[r0 + numDefine22] = f14;
                    heapClassInst.heapFloat[r0 + numDefine23] = f16;
                    heapClassInst.heapFloat[r0 + numDefine24] = f25;
                    heapClassInst.heap32[r0 + numDefine25] = heapClassInst.heap32[r1 + numDefine11];
                    heapClassInst.heapFloat[r0 + numDefine26] = f0;
                    heapClassInst.heapFloat[r0 + numDefine27] = f1;
                    heapClassInst.heapFloat[r0 + numDefine28] = f13;
                    heapClassInst.heap32[r0 + numDefine29] = heapClassInst.heap32[r1 + numDefine15];
                    r1 = sp + numDefineNeg976;
                    heapClassInst.heap32[r0 + numDefine10] = heapClassInst.heap32[r5 + 1];
                    r5 = r1 >> numDefine2;
                    heapClassInst.heapFloat[fp + numDefineNeg244] = f9;
                    heapClassInst.heapFloat[r5 + 1] = f11;
                    heapClassInst.heapFloat[r5 + numDefine2] = f3;
                    heapClassInst.heap32[r5 + numDefine3] = 0;
                    if (!(f6 >= f9)) {
                        heapClassInst.heapFloat[fp + numDefineNeg244] = f6;
                    }
                    if (!(f10 >= f11)) {
                        heapClassInst.heapFloat[r5 + 1] = f10;
                    }
                    if (!(f5 >= f3)) {
                        heapClassInst.heapFloat[r5 + numDefine2] = f5;
                    }
                    r5 = sp + numDefineNeg992;
                    r6 = r5 >> numDefine2;
                    heapClassInst.heapFloat[fp + numDefineNeg248] = f9;
                    heapClassInst.heapFloat[r6 + 1] = f11;
                    heapClassInst.heapFloat[r6 + numDefine2] = f3;
                    heapClassInst.heap32[r6 + numDefine3] = 0;
                    if (!(f9 >= f6)) {
                        heapClassInst.heapFloat[fp + numDefineNeg248] = f6;
                    }
                    if (!(f11 >= f10)) {
                        heapClassInst.heapFloat[r6 + 1] = f10;
                    }
                    if (!(f3 >= f5)) {
                        heapClassInst.heapFloat[r6 + numDefine2] = f5;
                    }
                    r3 = heapClassInst.heap32[r3];
                    r3 = r3 >> numDefine2;
                    r3 = heapClassInst.heap32[r3 + numDefine15];
                    heapClassInst.heap32[g0] = r2;
                    heapClassInst.heap32[g0 + 1] = r4;
                    heapClassInst.heap32[g0 + numDefine2] = r1;
                    heapClassInst.heap32[g0 + numDefine3] = r5;
                    r1 = ztv18btTriangleCallback;
                    r1 = (r1 + numDefine8) | 0;
                    functionTable.get(r3 >> numDefine2).accept(i7);
                    heapClassInst.heap32[fp + numDefineNeg240] = r1;
                    return;
                } else {
                    r1 = r7 >> numDefine2;
                    r4 = r4 >> numDefine2;
                    f0 = heapClassInst.heapFloat[r1 + numDefine12];
                    f1 = heapClassInst.heapFloat[r1 + numDefine13];
                    f2 = heapClassInst.heapFloat[r1 + numDefine4];
                    f3 = heapClassInst.heapFloat[r4 + numDefine13];
                    f4 = heapClassInst.heapFloat[r1];
                    f5 = heapClassInst.heapFloat[r4 + numDefine12];
                    f6 = -f0;
                    f7 = heapClassInst.heapFloat[r1 + numDefine5];
                    f8 = heapClassInst.heapFloat[r1 + 1];
                    f9 = heapClassInst.heapFloat[r1 + numDefine14];
                    f10 = heapClassInst.heapFloat[r1 + numDefine8];
                    f11 = heapClassInst.heapFloat[r4 + numDefine14];
                    f12 = f4 * f5;
                    f13 = f2 * f3;
                    f14 = f4 * f6;
                    f15 = f2 * f1;
                    f16 = heapClassInst.heapFloat[r1 + numDefine9];
                    f17 = heapClassInst.heapFloat[r1 + numDefine6];
                    f18 = heapClassInst.heapFloat[r1 + numDefine2];
                    f19 = f8 * f5;
                    f20 = f7 * f3;
                    f21 = f8 * f6;
                    f22 = f7 * f1;
                    f12 = f12 + f13;
                    f13 = f10 * f11;
                    f14 = f14 - f15;
                    f15 = f10 * f9;
                    f23 = heapClassInst.heapFloat[r1 + numDefine10];
                    f5 = f18 * f5;
                    f3 = f17 * f3;
                    f6 = f18 * f6;
                    f24 = f17 * f1;
                    f19 = f19 + f20;
                    f20 = f16 * f11;
                    f21 = f21 - f22;
                    f22 = f16 * f9;
                    f12 = f12 + f13;
                    f13 = f14 - f15;
                    r4 = sp + numDefineNeg704;
                    f12 = f12 + f13;
                    f3 = f5 + f3;
                    f5 = f23 * f11;
                    f6 = f6 - f24;
                    f11 = f23 * f9;
                    f14 = f19 + f20;
                    f15 = f21 - f22;
                    r7 = r4 >> numDefine2;
                    heapClassInst.heapFloat[fp + numDefineNeg176] = f12;
                    f14 = f14 + f15;
                    f3 = f3 + f5;
                    f5 = f6 - f11;
                    heapClassInst.heapFloat[r7 + 1] = f14;
                    f3 = f3 + f5;
                    heapClassInst.heapFloat[r7 + numDefine2] = f3;
                    r5 = r5 >> numDefine2;
                    heapClassInst.heap32[r7 + numDefine3] = 0;
                    f6 = heapClassInst.heapFloat[r5 + numDefine12];
                    f11 = heapClassInst.heapFloat[r5 + numDefine13];
                    f19 = heapClassInst.heapFloat[r5 + numDefine14];
                    f20 = f4 * f6;
                    f21 = f2 * f11;
                    f22 = f8 * f6;
                    f24 = f7 * f11;
                    f20 = f20 + f21;
                    f21 = f10 * f19;
                    f20 = f20 + f21;
                    f6 = f18 * f6;
                    f11 = f17 * f11;
                    f21 = f22 + f24;
                    f22 = f16 * f19;
                    r5 = sp + numDefineNeg720;
                    f21 = f21 + f22;
                    f13 = f20 + f13;
                    f6 = f6 + f11;
                    f11 = f23 * f19;
                    f6 = f6 + f11;
                    r7 = r5 >> numDefine2;
                    heapClassInst.heapFloat[fp + numDefineNeg180] = f13;
                    f11 = f21 + f15;
                    heapClassInst.heapFloat[r7 + 1] = f11;
                    f5 = f6 + f5;
                    heapClassInst.heapFloat[r7 + numDefine2] = f5;
                    r0 = sp + numDefineNeg840;
                    r9 = r8 >> numDefine2;
                    heapClassInst.heap32[r7 + numDefine3] = 0;
                    r7 = r0 >> numDefine2;
                    r10 = heapClassInst.heap32[r9 + numDefine4];
                    heapClassInst.heapFloat[r7 + 1] = f12;
                    heapClassInst.heapFloat[r7 + numDefine2] = f14;
                    heapClassInst.heapFloat[r7 + numDefine3] = f3;
                    heapClassInst.heap32[r7 + numDefine4] = 0;
                    heapClassInst.heapFloat[r7 + numDefine5] = f13;
                    heapClassInst.heapFloat[r7 + numDefine6] = f11;
                    heapClassInst.heapFloat[r7 + numDefine7] = f5;
                    r11 = ztvzn16CollsionTestERK;
                    heapClassInst.heap32[r7 + numDefine8] = 0;
                    r11 = (r11 + numDefine8) | 0;
                    heapClassInst.heap32[r7 + numDefine9] = r10;
                    heapClassInst.heap32[fp + numDefineNeg210] = r11;
                    heapClassInst.heap32[r7 + numDefine11] = r8;
                    heapClassInst.heap32[r7 + numDefine12] = r6;
                    heapClassInst.heap32[r7 + numDefine13] = r2;
                    heapClassInst.heapFloat[r7 + numDefine14] = f4;
                    heapClassInst.heapFloat[r7 + numDefine15] = f8;
                    heapClassInst.heapFloat[r7 + numDefine16] = f18;
                    heapClassInst.heap32[r7 + numDefine17] = heapClassInst.heap32[r1 + numDefine3];
                    heapClassInst.heapFloat[r7 + numDefine18] = f2;
                    heapClassInst.heapFloat[r7 + numDefine19] = f7;
                    heapClassInst.heapFloat[r7 + numDefine20] = f17;
                    heapClassInst.heap32[r7 + numDefine21] = heapClassInst.heap32[r1 + numDefine7];
                    heapClassInst.heapFloat[r7 + numDefine22] = f10;
                    heapClassInst.heapFloat[r7 + numDefine23] = f16;
                    heapClassInst.heapFloat[r7 + numDefine24] = f23;
                    heapClassInst.heap32[r7 + numDefine25] = heapClassInst.heap32[r1 + numDefine11];
                    heapClassInst.heapFloat[r7 + numDefine26] = f0;
                    heapClassInst.heapFloat[r7 + numDefine27] = f1;
                    heapClassInst.heapFloat[r7 + numDefine28] = f9;
                    heapClassInst.heap32[r7 + numDefine29] = heapClassInst.heap32[r1 + numDefine15];
                    r1 = ztvzn22btBvhTriangleMeshShape14performRaycastEP18btTriangleCallbackRK9btVector3S4E21MyNodeOverlapCallback;
                    heapClassInst.heap32[r7 + numDefine10] = heapClassInst.heap32[r9 + 1];
                    r2 = sp + numDefineNeg48;
                    r6 = heapClassInst.heap32[r3 + numDefine12];
                    r1 = (r1 + numDefine8) | 0;
                    r7 = r2 >> numDefine2;
                    heapClassInst.heap32[fp + numDefineNeg12] = r1;
                    heapClassInst.heap32[r7 + 1] = r6;
                    heapClassInst.heap32[r7 + numDefine2] = r0;
                    r1 = heapClassInst.heap32[r3 + numDefine13];
                    r3 = sp + numDefineNeg32;
                    r6 = r3 >> numDefine2;
                    heapClassInst.heap32[fp + numDefineNeg8] = 0;
                    heapClassInst.heap32[r6 + 1] = 0;
                    heapClassInst.heap32[r6 + numDefine2] = 0;
                    r7 = sp + numDefineNeg16;
                    heapClassInst.heap32[r6 + numDefine3] = 0;
                    r6 = r7 >> numDefine2;
                    heapClassInst.heap32[fp + numDefineNeg4] = 0;
                    heapClassInst.heap32[r6 + 1] = 0;
                    heapClassInst.heap32[r6 + numDefine2] = 0;
                    heapClassInst.heap32[r6 + numDefine3] = 0;
                    r6 = heapClassInst.heapU8[r1 + numDefine60];
                    if (r6 == 0) {
                        heapClassInst.heap32[g0] = r1;
                        heapClassInst.heap32[g0 + 1] = r2;
                        heapClassInst.heap32[g0 + numDefine2] = r4;
                        heapClassInst.heap32[g0 + numDefine3] = r5;
                        heapClassInst.heap32[g0 + numDefine4] = r7;
                        heapClassInst.heap32[g0 + numDefine5] = r3;
                        znk14btQuantizedBvh27walkStacklessTreeAgainstRayEP21btNodeOverlapCallbackRK9btVector3S4S4S4Ii(i7);
                    } else {
                        r6 = r1 >> numDefine2;
                        r6 = heapClassInst.heap32[r6 + numDefine14];
                        heapClassInst.heap32[g0] = r1;
                        heapClassInst.heap32[g0 + 1] = r2;
                        heapClassInst.heap32[g0 + numDefine2] = r4;
                        heapClassInst.heap32[g0 + numDefine3] = r5;
                        heapClassInst.heap32[g0 + numDefine4] = r7;
                        heapClassInst.heap32[g0 + numDefine5] = r3;
                        heapClassInst.heap32[g0 + numDefine6] = r6;
                        znk14btQuantizedBvh36walkStacklessQuantizedTreeAgainstRayEP21btNodeOverlapCallbackRK9btVector3S4S4S4Ii(i7);
                    }
                    r1 = ztv18btTriangleCallback;
                    r1 = (r1 + numDefine8) | 0;
                    heapClassInst.heap32[fp + numDefineNeg210] = r1;
                    return;
                }
            }
        } else {
            r1 = ztvn12btConvexCast10CastResultE;
            r3 = sp + numDefineNeg280;
            r1 = (r1 + numDefine8) | 0;
            r9 = r3 >> numDefine2;
            heapClassInst.heap32[fp + numDefineNeg70] = r1;
            heapClassInst.heap32[r9 + numDefine42] = 0;
            r1 = sp + numDefineNeg640;
            r10 = r8 >> numDefine2;
            heapClassInst.heap32[r9 + numDefine43] = 0;
            r11 = r1 >> numDefine2;
            heapClassInst.heap32[r9 + numDefine41] = heapClassInst.heap32[r10 + 1];
            r12 = ztv22btSubsimplexConvexCast;
            r13 = 0;
            heapClassInst.heap32[r11 + numDefine77] = numDefine67991;
            r11 = sp + numDefineNeg656;
            r12 = (r12 + numDefine8) | 0;
            heapClassInst.heap8[sp + numDefineNeg308] = (byte) r13;
            r13 = r11 >> numDefine2;
            heapClassInst.heap32[fp + numDefineNeg164] = r12;
            heapClassInst.heap32[r13 + 1] = r1;
            heapClassInst.heap32[r13 + numDefine2] = r0;
            heapClassInst.heap32[r13 + numDefine3] = r2;
            heapClassInst.heap32[g0] = r11;
            heapClassInst.heap32[g0 + 1] = r4;
            heapClassInst.heap32[g0 + numDefine2] = r5;
            heapClassInst.heap32[g0 + numDefine3] = r7;
            heapClassInst.heap32[g0 + numDefine4] = r7;
            heapClassInst.heap32[g0 + numDefine5] = r3;
            zn22btSubsimplexConvexCastTimeTransform(i7);
            r1 = commonVariable.rg0;
            if (!(r1 == 0)) {
                f0 = heapClassInst.heapFloat[r9 + numDefine33];
                f1 = heapClassInst.heapFloat[r9 + numDefine34];
                f2 = heapClassInst.heapFloat[r9 + numDefine35];
                f3 = f0 * f0;
                f4 = f1 * f1;
                f3 = f3 + f4;
                f4 = f2 * f2;
                f3 = f3 + f4;
                f4 = (float) numDefineFloat9165;
                if (!(f3 <= f4)) {
                    f3 = heapClassInst.heapFloat[r9 + numDefine41];
                    f4 = heapClassInst.heapFloat[r10 + 1];
                    if (!(f3 >= f4)) {
                        r1 = r4 >> numDefine2;
                        f4 = heapClassInst.heapFloat[r1 + numDefine4];
                        f5 = heapClassInst.heapFloat[r1];
                        f6 = heapClassInst.heapFloat[r1 + numDefine5];
                        f7 = heapClassInst.heapFloat[r1 + 1];
                        f8 = heapClassInst.heapFloat[r1 + numDefine8];
                        f9 = heapClassInst.heapFloat[r1 + numDefine9];
                        f4 = f4 * f0;
                        f6 = f6 * f1;
                        f10 = heapClassInst.heapFloat[r1 + numDefine6];
                        f11 = heapClassInst.heapFloat[r1 + numDefine2];
                        f5 = f5 * f0;
                        f7 = f7 * f1;
                        f12 = heapClassInst.heapFloat[r1 + numDefine10];
                        f0 = f8 * f0;
                        f1 = f9 * f1;
                        f4 = f4 + f6;
                        f6 = f10 * f2;
                        f5 = f5 + f7;
                        f7 = f11 * f2;
                        f4 = f4 + f6;
                        f5 = f5 + f7;
                        f0 = f0 + f1;
                        f1 = f12 * f2;
                        f0 = f0 + f1;
                        f1 = f5 * f5;
                        f2 = f4 * f4;
                        heapClassInst.heap32[r9 + numDefine36] = 0;
                        f1 = f1 + f2;
                        f2 = f0 * f0;
                        f1 = f1 + f2;
                        heapClassInst.heapFloat[g0] = f1;
                        f1 = 1;
                        sqrtf(i7);
                        f1 = (float) (f1 / commonVariable.fg0);
                        f2 = f5 * f1;
                        f4 = f4 * f1;
                        heapClassInst.heapFloat[r9 + numDefine33] = f2;
                        f0 = f0 * f1;
                        heapClassInst.heapFloat[r9 + numDefine34] = f4;
                        r1 = sp + numDefineNeg688;
                        heapClassInst.heapFloat[r9 + numDefine35] = f0;
                        r2 = r1 >> numDefine2;
                        heapClassInst.heap32[fp + numDefineNeg172] = r6;
                        heapClassInst.heap32[r2 + 1] = 0;
                        heapClassInst.heapFloat[r2 + numDefine2] = f2;
                        heapClassInst.heapFloat[r2 + numDefine3] = f4;
                        heapClassInst.heapFloat[r2 + numDefine4] = f0;
                        heapClassInst.heap32[r2 + numDefine5] = 0;
                        heapClassInst.heapFloat[r2 + numDefine6] = f3;
                        r2 = heapClassInst.heap32[r10];
                        r2 = r2 >> numDefine2;
                        r2 = heapClassInst.heap32[r2 + numDefine3];
                        heapClassInst.heap32[g0] = r8;
                        heapClassInst.heap32[g0 + 1] = r1;
                        heapClassInst.heap32[g0 + numDefine2] = 1;
                        functionTable.get(r2 >> numDefine2).accept(i7);
                    }
                }
            }
            r1 = ztv12btConvexCast;
            r1 = (r1 + numDefine8) | 0;
            heapClassInst.heap32[fp + numDefineNeg164] = r1;
            return;
        }
    }

    public static void zn22btCompoundLeafCallbackD1Ev(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int label = 0;
        i7 = sp + 0;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = ztv22btCompoundLeafCallback;
        r0 = r0 >> numDefine2;
        r1 = (r1 + numDefine8) | 0;
        heapClassInst.heap32[r0] = r1;
        
    }

    public static void zn22btCompoundLeafCallbackD0Ev(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int label = 0;
        i7 = sp + numDefineNeg8;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = ztv22btCompoundLeafCallback;
        r2 = r0 >> numDefine2;
        r1 = (r1 + numDefine8) | 0;
        heapClassInst.heap32[r2] = r1;
        heapClassInst.heap32[g0] = r0;
        zdlPv(i7);
        
    }

    public static void zn22btCompoundLeafCallback7ProcessEPK10btDbvtNode(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        int r6 = 0;
        int r7 = 0;
        int r8 = 0;
        int label = 0;
        i7 = sp + numDefineNeg136;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = r0 >> numDefine2;
        r2 = heapClassInst.heap32[r1 + 1];
        r3 = heapClassInst.heap32[fp + 1];
        r2 = r2 >> numDefine2;
        r2 = heapClassInst.heap32[r2 + numDefine48];
        r4 = r3 >> numDefine2;
        r4 = heapClassInst.heap32[r4 + numDefine9];
        r2 = r2 >> numDefine2;
        r2 = heapClassInst.heap32[r2 + numDefine6];
        r5 = (r4 * numDefine80) | 0;
        r6 = heapClassInst.heap32[r1 + numDefine4];
        r2 = (r2 + r5) | 0;
        r5 = r6 >> numDefine2;
        r2 = r2 >> numDefine2;
        r5 = heapClassInst.heap32[r5 + numDefine5];
        r2 = heapClassInst.heap32[r2 + numDefine16];
        if (!(r5 == 0)) {
            r6 = r5 >> numDefine2;
            r6 = heapClassInst.heap32[r6];
            r6 = r6 >> numDefine2;
            r6 = heapClassInst.heap32[r6 + numDefine12];
            heapClassInst.heap32[g0] = r5;
            functionTable.get(r6 >> numDefine2).accept(i7);
            r5 = commonVariable.rg0 & numDefine2;
            if (!(r5 == 0)) {
                r5 = heapClassInst.heap32[r1 + 1];
                r6 = sp + numDefineNeg112;
                r5 = r5 >> numDefine2;
                r7 = r6 >> numDefine2;
                heapClassInst.heap32[fp + numDefineNeg28] = heapClassInst.heap32[r5 + 1];
                heapClassInst.heap32[r7 + 1] = heapClassInst.heap32[r5 + numDefine2];
                heapClassInst.heap32[r7 + numDefine2] = heapClassInst.heap32[r5 + numDefine3];
                heapClassInst.heap32[r7 + numDefine3] = heapClassInst.heap32[r5 + numDefine4];
                heapClassInst.heap32[r7 + numDefine4] = heapClassInst.heap32[r5 + numDefine5];
                heapClassInst.heap32[r7 + numDefine5] = heapClassInst.heap32[r5 + numDefine6];
                heapClassInst.heap32[r7 + numDefine6] = heapClassInst.heap32[r5 + numDefine7];
                heapClassInst.heap32[r7 + numDefine7] = heapClassInst.heap32[r5 + numDefine8];
                heapClassInst.heap32[r7 + numDefine8] = heapClassInst.heap32[r5 + numDefine9];
                heapClassInst.heap32[r7 + numDefine9] = heapClassInst.heap32[r5 + numDefine10];
                heapClassInst.heap32[r7 + numDefine10] = heapClassInst.heap32[r5 + numDefine11];
                heapClassInst.heap32[r7 + numDefine11] = heapClassInst.heap32[r5 + numDefine12];
                heapClassInst.heap32[r7 + numDefine12] = heapClassInst.heap32[r5 + numDefine13];
                heapClassInst.heap32[r7 + numDefine13] = heapClassInst.heap32[r5 + numDefine14];
                heapClassInst.heap32[r7 + numDefine14] = heapClassInst.heap32[r5 + numDefine15];
                heapClassInst.heap32[r7 + numDefine15] = heapClassInst.heap32[r5 + numDefine16];
                r5 = (r3 + numDefine16) | 0;
                r7 = sp + numDefineNeg32;
                r8 = sp + numDefineNeg48;
                heapClassInst.heap32[g0] = r3;
                heapClassInst.heap32[g0 + 1] = r5;
                heapClassInst.heap32[g0 + numDefine2] = 0;
                heapClassInst.heap32[g0 + numDefine3] = r6;
                heapClassInst.heap32[g0 + numDefine4] = r7;
                heapClassInst.heap32[g0 + numDefine5] = r8;
                z15btTransformAabbRK9btVector3S1FRK11btTransformRSS5(i7);
                r1 = heapClassInst.heap32[r1 + numDefine4];
                r1 = r1 >> numDefine2;
                r3 = heapClassInst.heap32[r1 + numDefine5];
                r3 = r3 >> numDefine2;
                r3 = heapClassInst.heap32[r3];
                r3 = r3 >> numDefine2;
                r3 = heapClassInst.heap32[r3 + numDefine13];
                r5 = sp + numDefineNeg16;
                r6 = r5 >> numDefine2;
                heapClassInst.heap32[fp + numDefineNeg4] = numDefine53216;
                heapClassInst.heap32[r6 + 1] = 0;
                heapClassInst.heap32[r6 + numDefine2] = 0;
                heapClassInst.heap32[r6 + numDefine3] = 0;
                r1 = heapClassInst.heap32[r1 + numDefine5];
                heapClassInst.heap32[g0] = r1;
                heapClassInst.heap32[g0 + 1] = r7;
                heapClassInst.heap32[g0 + numDefine2] = r8;
                heapClassInst.heap32[g0 + numDefine3] = r5;
                functionTable.get(r3 >> numDefine2).accept(i7);
            }
        }
        heapClassInst.heap32[g0] = r0;
        heapClassInst.heap32[g0 + 1] = r2;
        heapClassInst.heap32[g0 + numDefine2] = r4;
        zn22btCompoundLeafCallback17ProcessChildShapeEP16btCollisionShapei(i7);
        
    }

    public static void zn28btCompoundCollisionAlgorithm22getAllContactManifoldsER20btAlignedObjectArrayIP20btPersistentManifoldE(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int label = 0;
        i7 = sp + numDefineNeg8;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r0 = r0 >> numDefine2;
        r1 = heapClassInst.heap32[r0 + numDefine3];
        if (!(r1 < 1)) {
            r1 = heapClassInst.heap32[fp + 1];
            r2 = 0;
            repeat3:
            while (true) {
                r3 = heapClassInst.heap32[r0 + numDefine5];
                r4 = r2 << numDefine2;
                r3 = (r3 + r4) | 0;
                r3 = r3 >> numDefine2;
                r3 = heapClassInst.heap32[r3];
                if (!(r3 == 0)) {
                    r4 = r3 >> numDefine2;
                    r4 = heapClassInst.heap32[r4];
                    r4 = r4 >> numDefine2;
                    r4 = heapClassInst.heap32[r4 + numDefine4];
                    heapClassInst.heap32[g0] = r3;
                    heapClassInst.heap32[g0 + 1] = r1;
                    functionTable.get(r4 >> numDefine2).accept(i7);
                }
                r2 = (r2 + 1) | 0;
                r3 = heapClassInst.heap32[r0 + numDefine3];
                if (r3 > r2) {
                    continue repeat3;
                } else {
                    break repeat3;
                }
            }
        }
        
    }

    public static void zn28btCompoundCollisionAlgorithm21calculateTimeOfImpactEP17btCollisionObjectS1RK16btDispatcherInfoP16btManifoldResult(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        int r6 = 0;
        int r7 = 0;
        int r8 = 0;
        int r9 = 0;
        int r10 = 0;
        int r11 = 0;
        float f0 = 0.0F;
        float f1 = 0.0F;
        float f2 = 0.0F;
        float f3 = 0.0F;
        float f4 = 0.0F;
        float f5 = 0.0F;
        float f6 = 0.0F;
        float f7 = 0.0F;
        float f8 = 0.0F;
        float f9 = 0.0F;
        float f10 = 0.0F;
        float f11 = 0.0F;
        float f12 = 0.0F;
        float f13 = 0.0F;
        float f14 = 0.0F;
        float f15 = 0.0F;
        float f16 = 0.0F;
        float f17 = 0.0F;
        float f18 = 0.0F;
        float f19 = 0.0F;
        float f20 = 0.0F;
        float f21 = 0.0F;
        float f22 = 0.0F;
        float f23 = 0.0F;
        float f24 = 0.0F;
        float f25 = 0.0F;
        float f26 = 0.0F;
        float f27 = 0.0F;
        float f28 = 0.0F;
        float f29 = 0.0F;
        float f30 = 0.0F;
        int label = 0;
        i7 = sp + numDefineNeg40;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = heapClassInst.heapU8[r0 + numDefine28];
        r2 = heapClassInst.heap32[fp + 1];
        r3 = heapClassInst.heap32[fp + numDefine2];
        r4 = r1 == 0 ? r2 : r3;
        r5 = r4 >> numDefine2;
        r6 = heapClassInst.heap32[r5 + numDefine48];
        r7 = r6 >> numDefine2;
        r8 = heapClassInst.heap32[r7 + 1];
        if (r8 == numDefine31) {
            r0 = r0 >> numDefine2;
            r8 = heapClassInst.heap32[r0 + numDefine3];
            repeat3:
            do {
                if (r8 > 0) {
                    r9 = heapClassInst.heap32[fp + numDefine3];
                    r10 = heapClassInst.heap32[fp + numDefine4];
                    r1 = r1 == 0 ? r3 : r2;
                    r2 = 0;
                    f0 = 1;
                    while (true) {
                        r3 = (r2 * numDefine20) | 0;
                        r11 = heapClassInst.heap32[r7 + numDefine6];
                        r3 = r3 << numDefine2;
                        r3 = (r11 + r3) | 0;
                        r3 = r3 >> numDefine2;
                        f1 = heapClassInst.heapFloat[r3];
                        f2 = heapClassInst.heapFloat[r5 + 1];
                        f3 = heapClassInst.heapFloat[r3 + numDefine4];
                        f4 = heapClassInst.heapFloat[r5 + numDefine2];
                        f5 = heapClassInst.heapFloat[r3 + 1];
                        f6 = heapClassInst.heapFloat[r3 + numDefine5];
                        f7 = f1 * f2;
                        f8 = f3 * f4;
                        f9 = heapClassInst.heapFloat[r3 + numDefine8];
                        f10 = heapClassInst.heapFloat[r5 + numDefine3];
                        f11 = heapClassInst.heapFloat[r5 + numDefine10];
                        f12 = heapClassInst.heapFloat[r3 + numDefine13];
                        f13 = heapClassInst.heapFloat[r5 + numDefine6];
                        f14 = heapClassInst.heapFloat[r3 + numDefine6];
                        f15 = heapClassInst.heapFloat[r5 + numDefine9];
                        f16 = heapClassInst.heapFloat[r3 + numDefine12];
                        f17 = heapClassInst.heapFloat[r5 + numDefine5];
                        f18 = heapClassInst.heapFloat[r3 + numDefine2];
                        f19 = heapClassInst.heapFloat[r3 + numDefine14];
                        f20 = heapClassInst.heapFloat[r5 + numDefine11];
                        f21 = heapClassInst.heapFloat[r3 + numDefine10];
                        f22 = heapClassInst.heapFloat[r5 + numDefine7];
                        f23 = heapClassInst.heapFloat[r3 + numDefine9];
                        r3 = heapClassInst.heap32[r3 + numDefine16];
                        f24 = f5 * f2;
                        f25 = f6 * f4;
                        f7 = f7 + f8;
                        f8 = f9 * f10;
                        f26 = heapClassInst.heapFloat[r5 + numDefine16];
                        heapClassInst.heapFloat[fp + -1] = f26;
                        f27 = heapClassInst.heapFloat[r5 + numDefine15];
                        f28 = heapClassInst.heapFloat[r5 + numDefine14];
                        f29 = heapClassInst.heapFloat[r5 + numDefine13];
                        f26 = heapClassInst.heapFloat[r5 + numDefine12];
                        heapClassInst.heapFloat[fp + numDefineNeg2] = f26;
                        f26 = heapClassInst.heapFloat[r5 + numDefine8];
                        heapClassInst.heapFloat[fp + numDefineNeg3] = f26;
                        f26 = heapClassInst.heapFloat[r5 + numDefine4];
                        heapClassInst.heapFloat[fp + numDefineNeg4] = f26;
                        f30 = f18 * f2;
                        f26 = f14 * f4;
                        f24 = f24 + f25;
                        f25 = f23 * f10;
                        f7 = f7 + f8;
                        f8 = f30 + f26;
                        f26 = f21 * f10;
                        f24 = f24 + f25;
                        heapClassInst.heapFloat[r5 + 1] = f7;
                        f7 = f1 * f17;
                        f25 = f3 * f13;
                        f8 = f8 + f26;
                        heapClassInst.heapFloat[r5 + numDefine2] = f24;
                        heapClassInst.heapFloat[r5 + numDefine3] = f8;
                        f8 = f5 * f17;
                        f24 = f6 * f13;
                        f7 = f7 + f25;
                        f25 = f9 * f22;
                        f26 = f18 * f17;
                        f30 = f14 * f13;
                        f8 = f8 + f24;
                        f24 = f23 * f22;
                        f7 = f7 + f25;
                        heapClassInst.heap32[r5 + numDefine4] = 0;
                        f25 = f26 + f30;
                        f26 = f21 * f22;
                        f8 = f8 + f24;
                        heapClassInst.heapFloat[r5 + numDefine5] = f7;
                        f1 = f1 * f15;
                        f3 = f3 * f11;
                        f7 = f25 + f26;
                        heapClassInst.heapFloat[r5 + numDefine6] = f8;
                        heapClassInst.heapFloat[r5 + numDefine7] = f7;
                        f5 = f5 * f15;
                        f6 = f6 * f11;
                        f1 = f1 + f3;
                        f3 = f9 * f20;
                        f7 = f18 * f15;
                        f8 = f14 * f11;
                        f5 = f5 + f6;
                        f6 = f23 * f20;
                        f1 = f1 + f3;
                        heapClassInst.heap32[r5 + numDefine8] = 0;
                        f3 = f2 * f16;
                        f9 = f4 * f12;
                        f7 = f7 + f8;
                        f8 = f21 * f20;
                        f5 = f5 + f6;
                        heapClassInst.heapFloat[r5 + numDefine9] = f1;
                        f1 = f17 * f16;
                        f6 = f13 * f12;
                        f3 = f3 + f9;
                        f9 = f10 * f19;
                        f7 = f7 + f8;
                        heapClassInst.heapFloat[r5 + numDefine10] = f5;
                        f3 = f3 + f9;
                        heapClassInst.heapFloat[r5 + numDefine11] = f7;
                        f5 = f15 * f16;
                        f7 = f11 * f12;
                        f1 = f1 + f6;
                        f6 = f22 * f19;
                        f1 = f1 + f6;
                        f5 = f5 + f7;
                        f6 = f20 * f19;
                        f3 = f3 + f29;
                        heapClassInst.heap32[r5 + numDefine12] = 0;
                        f5 = f5 + f6;
                        f1 = f1 + f28;
                        heapClassInst.heapFloat[r5 + numDefine13] = f3;
                        f3 = f5 + f27;
                        heapClassInst.heapFloat[r5 + numDefine14] = f1;
                        heapClassInst.heapFloat[r5 + numDefine15] = f3;
                        heapClassInst.heap32[r5 + numDefine16] = 0;
                        heapClassInst.heap32[r5 + numDefine48] = r3;
                        r3 = heapClassInst.heap32[r0 + numDefine5];
                        r11 = r2 << numDefine2;
                        r3 = (r3 + r11) | 0;
                        r3 = r3 >> numDefine2;
                        r3 = heapClassInst.heap32[r3];
                        r11 = r3 >> numDefine2;
                        r11 = heapClassInst.heap32[r11];
                        r11 = r11 >> numDefine2;
                        r11 = heapClassInst.heap32[r11 + numDefine3];
                        heapClassInst.heap32[g0] = r3;
                        heapClassInst.heap32[g0 + 1] = r4;
                        heapClassInst.heap32[g0 + numDefine2] = r1;
                        heapClassInst.heap32[g0 + numDefine3] = r9;
                        heapClassInst.heap32[g0 + numDefine4] = r10;
                        functionTable.get(r11 >> numDefine2).accept(i7);
                        heapClassInst.heap32[r5 + numDefine48] = r6;
                        heapClassInst.heapFloat[r5 + 1] = f2;
                        heapClassInst.heapFloat[r5 + numDefine2] = f4;
                        heapClassInst.heapFloat[r5 + numDefine3] = f10;
                        f26 = heapClassInst.heapFloat[fp + numDefineNeg4];
                        heapClassInst.heapFloat[r5 + numDefine4] = f26;
                        heapClassInst.heapFloat[r5 + numDefine5] = f17;
                        heapClassInst.heapFloat[r5 + numDefine6] = f13;
                        heapClassInst.heapFloat[r5 + numDefine7] = f22;
                        f26 = heapClassInst.heapFloat[fp + numDefineNeg3];
                        heapClassInst.heapFloat[r5 + numDefine8] = f26;
                        heapClassInst.heapFloat[r5 + numDefine9] = f15;
                        heapClassInst.heapFloat[r5 + numDefine10] = f11;
                        heapClassInst.heapFloat[r5 + numDefine11] = f20;
                        f26 = heapClassInst.heapFloat[fp + numDefineNeg2];
                        heapClassInst.heapFloat[r5 + numDefine12] = f26;
                        heapClassInst.heapFloat[r5 + numDefine13] = f29;
                        heapClassInst.heapFloat[r5 + numDefine14] = f28;
                        r2 = (r2 + 1) | 0;
                        f0 = commonVariable.fg0 < f0 ? (float) commonVariable.fg0 : f0;
                        heapClassInst.heapFloat[r5 + numDefine15] = f27;
                        f26 = heapClassInst.heapFloat[fp + -1];
                        heapClassInst.heapFloat[r5 + numDefine16] = f26;
                        if (!(r8 != r2)) {
                            break repeat3;
                        }
                    }
                } else {
                    f0 = 1;
                }
            } while (false);
            commonVariable.fg0 = f0;
            
        } else {
            r0 = twoEStr99;
            r1 = twoEStr1100;
            heapClassInst.heap32[g0] = r0;
            heapClassInst.heap32[g0 + 1] = r1;
            heapClassInst.heap32[g0 + numDefine2] = numDefine308;
            assertNew(i7);
        }
        
    }

    public static void zn22btCompoundLeafCallback17ProcessChildShapeEP16btCollisionShapei(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        int r6 = 0;
        int r7 = 0;
        int r8 = 0;
        int r9 = 0;
        int r10 = 0;
        int r11 = 0;
        int r12 = 0;
        int r13 = 0;
        float f0 = 0.0F;
        float f1 = 0.0F;
        float f2 = 0.0F;
        float f3 = 0.0F;
        float f4 = 0.0F;
        float f5 = 0.0F;
        float f6 = 0.0F;
        float f7 = 0.0F;
        float f8 = 0.0F;
        float f9 = 0.0F;
        float f10 = 0.0F;
        float f11 = 0.0F;
        float f12 = 0.0F;
        float f13 = 0.0F;
        float f14 = 0.0F;
        float f15 = 0.0F;
        float f16 = 0.0F;
        float f17 = 0.0F;
        float f18 = 0.0F;
        float f19 = 0.0F;
        float f20 = 0.0F;
        float f21 = 0.0F;
        float f22 = 0.0F;
        float f23 = 0.0F;
        float f24 = 0.0F;
        float f25 = 0.0F;
        float f26 = 0.0F;
        float f27 = 0.0F;
        float f28 = 0.0F;
        float f29 = 0.0F;
        float f30 = 0.0F;
        int label = 0;
        i7 = sp + numDefineNeg264;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp + numDefine2];
        if (r0 > -1) {
            r1 = heapClassInst.heap32[fp];
            r1 = r1 >> numDefine2;
            r2 = heapClassInst.heap32[r1 + 1];
            r2 = r2 >> numDefine2;
            r3 = heapClassInst.heap32[r2 + numDefine48];
            r3 = r3 >> numDefine2;
            r4 = heapClassInst.heap32[r3 + numDefine4];
            if (r4 > r0) {
                r4 = heapClassInst.heap32[fp + 1];
                r3 = heapClassInst.heap32[r3 + numDefine6];
                r5 = (r0 * numDefine80) | 0;
                r3 = (r3 + r5) | 0;
                r3 = r3 >> numDefine2;
                f0 = heapClassInst.heapFloat[r2 + 1];
                f1 = heapClassInst.heapFloat[r3];
                f2 = heapClassInst.heapFloat[r2 + numDefine2];
                f3 = heapClassInst.heapFloat[r3 + numDefine4];
                f4 = heapClassInst.heapFloat[r3 + 1];
                f5 = heapClassInst.heapFloat[r3 + numDefine5];
                f6 = heapClassInst.heapFloat[r2 + numDefine3];
                f7 = heapClassInst.heapFloat[r3 + numDefine8];
                f8 = f1 * f0;
                f9 = f3 * f2;
                f10 = heapClassInst.heapFloat[r2 + numDefine5];
                f11 = heapClassInst.heapFloat[r2 + numDefine6];
                f12 = heapClassInst.heapFloat[r2 + numDefine9];
                f13 = heapClassInst.heapFloat[r3 + numDefine12];
                f14 = heapClassInst.heapFloat[r3 + numDefine2];
                f15 = heapClassInst.heapFloat[r2 + numDefine10];
                f16 = heapClassInst.heapFloat[r3 + numDefine13];
                f17 = heapClassInst.heapFloat[r3 + numDefine6];
                f18 = heapClassInst.heapFloat[r2 + numDefine7];
                f19 = heapClassInst.heapFloat[r3 + numDefine14];
                f20 = heapClassInst.heapFloat[r2 + numDefine11];
                f21 = heapClassInst.heapFloat[r3 + numDefine10];
                f22 = heapClassInst.heapFloat[r3 + numDefine9];
                f23 = heapClassInst.heapFloat[r2 + numDefine4];
                f24 = heapClassInst.heapFloat[r2 + numDefine8];
                heapClassInst.heapFloat[fp + numDefineNeg59] = f24;
                f24 = heapClassInst.heapFloat[r2 + numDefine12];
                heapClassInst.heapFloat[fp + numDefineNeg57] = f24;
                f24 = heapClassInst.heapFloat[r2 + numDefine13];
                f25 = heapClassInst.heapFloat[r2 + numDefine14];
                f26 = heapClassInst.heapFloat[r2 + numDefine15];
                f27 = heapClassInst.heapFloat[r2 + numDefine16];
                heapClassInst.heapFloat[fp + numDefineNeg58] = f27;
                f27 = heapClassInst.heapFloat[r2 + numDefine17];
                heapClassInst.heapFloat[fp + numDefineNeg42] = f27;
                f27 = heapClassInst.heapFloat[r2 + numDefine18];
                heapClassInst.heapFloat[fp + numDefineNeg41] = f27;
                f27 = heapClassInst.heapFloat[r2 + numDefine19];
                heapClassInst.heapFloat[fp + numDefineNeg44] = f27;
                f27 = heapClassInst.heapFloat[r2 + numDefine20];
                heapClassInst.heapFloat[fp + numDefineNeg43] = f27;
                f27 = heapClassInst.heapFloat[r2 + numDefine21];
                heapClassInst.heapFloat[fp + numDefineNeg46] = f27;
                f27 = heapClassInst.heapFloat[r2 + numDefine22];
                heapClassInst.heapFloat[fp + numDefineNeg45] = f27;
                f27 = heapClassInst.heapFloat[r2 + numDefine23];
                heapClassInst.heapFloat[fp + numDefineNeg48] = f27;
                f27 = heapClassInst.heapFloat[r2 + numDefine24];
                heapClassInst.heapFloat[fp + numDefineNeg47] = f27;
                f27 = heapClassInst.heapFloat[r2 + numDefine25];
                heapClassInst.heapFloat[fp + numDefineNeg50] = f27;
                f27 = heapClassInst.heapFloat[r2 + numDefine26];
                heapClassInst.heapFloat[fp + numDefineNeg49] = f27;
                f27 = heapClassInst.heapFloat[r2 + numDefine27];
                heapClassInst.heapFloat[fp + numDefineNeg52] = f27;
                f27 = heapClassInst.heapFloat[r2 + numDefine28];
                heapClassInst.heapFloat[fp + numDefineNeg51] = f27;
                f27 = heapClassInst.heapFloat[r2 + numDefine29];
                heapClassInst.heapFloat[fp + numDefineNeg54] = f27;
                f27 = heapClassInst.heapFloat[r2 + numDefine30];
                heapClassInst.heapFloat[fp + numDefineNeg53] = f27;
                f27 = heapClassInst.heapFloat[r2 + numDefine31];
                heapClassInst.heapFloat[fp + numDefineNeg56] = f27;
                f27 = heapClassInst.heapFloat[r2 + numDefine32];
                heapClassInst.heapFloat[fp + numDefineNeg55] = f27;
                f27 = (int) (f4 * f0);
                f28 = f5 * f2;
                f8 = f8 + f9;
                f9 = f7 * f6;
                r2 = sp + numDefineNeg96;
                f29 = f14 * f0;
                f30 = f17 * f2;
                f27 = f27 + f28;
                f28 = f22 * f6;
                f8 = f8 + f9;
                r3 = r2 >> numDefine2;
                f9 = f29 + f30;
                f29 = f21 * f6;
                f27 = f27 + f28;
                heapClassInst.heapFloat[fp + numDefineNeg24] = f8;
                f8 = f1 * f10;
                f28 = f3 * f11;
                f9 = f9 + f29;
                heapClassInst.heapFloat[r3 + 1] = f27;
                heapClassInst.heapFloat[r3 + numDefine2] = f9;
                f9 = f4 * f10;
                f27 = f5 * f11;
                f8 = f8 + f28;
                f28 = f7 * f18;
                f29 = f14 * f10;
                f30 = f17 * f11;
                f9 = f9 + f27;
                f27 = f22 * f18;
                f8 = f8 + f28;
                heapClassInst.heap32[r3 + numDefine3] = 0;
                f28 = f29 + f30;
                f29 = f21 * f18;
                f9 = f9 + f27;
                heapClassInst.heapFloat[r3 + numDefine4] = f8;
                f1 = f1 * f12;
                f3 = f3 * f15;
                f8 = f28 + f29;
                heapClassInst.heapFloat[r3 + numDefine5] = f9;
                heapClassInst.heapFloat[r3 + numDefine6] = f8;
                f4 = f4 * f12;
                f5 = f5 * f15;
                f1 = f1 + f3;
                f3 = f7 * f20;
                f7 = f14 * f12;
                f8 = f17 * f15;
                f4 = f4 + f5;
                f5 = f22 * f20;
                f1 = f1 + f3;
                heapClassInst.heap32[r3 + numDefine7] = 0;
                f3 = f0 * f13;
                f9 = f2 * f16;
                f7 = f7 + f8;
                f8 = f21 * f20;
                f4 = f4 + f5;
                heapClassInst.heapFloat[r3 + numDefine8] = f1;
                f1 = f10 * f13;
                f5 = f11 * f16;
                f3 = f3 + f9;
                f9 = f6 * f19;
                f7 = f7 + f8;
                heapClassInst.heapFloat[r3 + numDefine9] = f4;
                f3 = f3 + f9;
                heapClassInst.heapFloat[r3 + numDefine10] = f7;
                f4 = f12 * f13;
                f7 = f15 * f16;
                f1 = f1 + f5;
                f5 = f18 * f19;
                f1 = f1 + f5;
                f4 = f4 + f7;
                f5 = f20 * f19;
                f3 = f3 + f24;
                heapClassInst.heap32[r3 + numDefine11] = 0;
                f4 = f4 + f5;
                f1 = f1 + f25;
                heapClassInst.heapFloat[r3 + numDefine12] = f3;
                f3 = f4 + f26;
                heapClassInst.heapFloat[r3 + numDefine13] = f1;
                heapClassInst.heapFloat[r3 + numDefine14] = f3;
                r5 = r4 >> numDefine2;
                heapClassInst.heap32[r3 + numDefine15] = 0;
                r5 = heapClassInst.heap32[r5];
                r5 = r5 >> numDefine2;
                r5 = heapClassInst.heap32[r5 + numDefine2];
                r6 = sp + numDefineNeg112;
                r7 = sp + numDefineNeg128;
                heapClassInst.heap32[g0] = r4;
                heapClassInst.heap32[g0 + 1] = r2;
                heapClassInst.heap32[g0 + numDefine2] = r6;
                heapClassInst.heap32[g0 + numDefine3] = r7;
                functionTable.get(r5 >> numDefine2).accept(i7);
                r2 = heapClassInst.heap32[r1 + numDefine2];
                r5 = r2 >> numDefine2;
                r5 = heapClassInst.heap32[r5 + numDefine48];
                r8 = r5 >> numDefine2;
                r8 = heapClassInst.heap32[r8];
                r8 = r8 >> numDefine2;
                r8 = heapClassInst.heap32[r8 + numDefine2];
                r2 = (r2 + numDefine4) | 0;
                r9 = sp + numDefineNeg144;
                r10 = sp + numDefineNeg160;
                heapClassInst.heap32[g0] = r5;
                heapClassInst.heap32[g0 + 1] = r2;
                heapClassInst.heap32[g0 + numDefine2] = r9;
                heapClassInst.heap32[g0 + numDefine3] = r10;
                functionTable.get(r8 >> numDefine2).accept(i7);
                f1 = heapClassInst.heapFloat[fp + numDefineNeg28];
                f3 = heapClassInst.heapFloat[fp + numDefineNeg40];
                if (f1 > f3) {
                    label = numDefine7;
                } else {
                    f1 = heapClassInst.heapFloat[fp + numDefineNeg32];
                    f3 = heapClassInst.heapFloat[fp + numDefineNeg36];
                    if (f1 < f3) {
                        label = numDefine7;
                    } else {
                        r2 = 1;
                        label = numDefine8;
                    }
                }
                if (label == numDefine7) {
                    r2 = 0;
                }
                r5 = r6 >> numDefine2;
                r8 = r10 >> numDefine2;
                f1 = heapClassInst.heapFloat[r5 + numDefine2];
                f3 = heapClassInst.heapFloat[r8 + numDefine2];
                if (f1 > f3) {
                    label = numDefine10;
                } else {
                    r11 = r7 >> numDefine2;
                    r12 = r9 >> numDefine2;
                    f1 = heapClassInst.heapFloat[r11 + numDefine2];
                    f3 = heapClassInst.heapFloat[r12 + numDefine2];
                    if (f1 < f3) {
                        label = numDefine10;
                    } else {
                        label = numDefine11;
                    }
                }
                if (label == numDefine10) {
                    r2 = 0;
                }
                f1 = heapClassInst.heapFloat[r5 + 1];
                f3 = heapClassInst.heapFloat[r8 + 1];
                if (!(f1 > f3)) {
                    r5 = r7 >> numDefine2;
                    r8 = r9 >> numDefine2;
                    f1 = heapClassInst.heapFloat[r5 + 1];
                    f3 = heapClassInst.heapFloat[r8 + 1];
                    if (!(f1 < f3)) {
                        r2 = r2 & numDefine255;
                        if (!(r2 == 0)) {
                            r2 = heapClassInst.heap32[r1 + 1];
                            r2 = r2 >> numDefine2;
                            heapClassInst.heap32[r2 + 1] = heapClassInst.heap32[fp + numDefineNeg24];
                            heapClassInst.heap32[r2 + numDefine2] = heapClassInst.heap32[r3 + 1];
                            heapClassInst.heap32[r2 + numDefine3] = heapClassInst.heap32[r3 + numDefine2];
                            heapClassInst.heap32[r2 + numDefine4] = heapClassInst.heap32[r3 + numDefine3];
                            heapClassInst.heap32[r2 + numDefine5] = heapClassInst.heap32[r3 + numDefine4];
                            heapClassInst.heap32[r2 + numDefine6] = heapClassInst.heap32[r3 + numDefine5];
                            heapClassInst.heap32[r2 + numDefine7] = heapClassInst.heap32[r3 + numDefine6];
                            heapClassInst.heap32[r2 + numDefine8] = heapClassInst.heap32[r3 + numDefine7];
                            heapClassInst.heap32[r2 + numDefine9] = heapClassInst.heap32[r3 + numDefine8];
                            heapClassInst.heap32[r2 + numDefine10] = heapClassInst.heap32[r3 + numDefine9];
                            heapClassInst.heap32[r2 + numDefine11] = heapClassInst.heap32[r3 + numDefine10];
                            heapClassInst.heap32[r2 + numDefine12] = heapClassInst.heap32[r3 + numDefine11];
                            heapClassInst.heap32[r2 + numDefine13] = heapClassInst.heap32[r3 + numDefine12];
                            heapClassInst.heap32[r2 + numDefine14] = heapClassInst.heap32[r3 + numDefine13];
                            heapClassInst.heap32[r2 + numDefine15] = heapClassInst.heap32[r3 + numDefine14];
                            heapClassInst.heap32[r2 + numDefine16] = heapClassInst.heap32[r3 + numDefine15];
                            r2 = heapClassInst.heap32[r1 + 1];
                            r2 = r2 >> numDefine2;
                            heapClassInst.heap32[r2 + numDefine17] = heapClassInst.heap32[fp + numDefineNeg24];
                            heapClassInst.heap32[r2 + numDefine18] = heapClassInst.heap32[r3 + 1];
                            heapClassInst.heap32[r2 + numDefine19] = heapClassInst.heap32[r3 + numDefine2];
                            heapClassInst.heap32[r2 + numDefine20] = heapClassInst.heap32[r3 + numDefine3];
                            heapClassInst.heap32[r2 + numDefine21] = heapClassInst.heap32[r3 + numDefine4];
                            heapClassInst.heap32[r2 + numDefine22] = heapClassInst.heap32[r3 + numDefine5];
                            heapClassInst.heap32[r2 + numDefine23] = heapClassInst.heap32[r3 + numDefine6];
                            heapClassInst.heap32[r2 + numDefine24] = heapClassInst.heap32[r3 + numDefine7];
                            heapClassInst.heap32[r2 + numDefine25] = heapClassInst.heap32[r3 + numDefine8];
                            heapClassInst.heap32[r2 + numDefine26] = heapClassInst.heap32[r3 + numDefine9];
                            heapClassInst.heap32[r2 + numDefine27] = heapClassInst.heap32[r3 + numDefine10];
                            heapClassInst.heap32[r2 + numDefine28] = heapClassInst.heap32[r3 + numDefine11];
                            heapClassInst.heap32[r2 + numDefine29] = heapClassInst.heap32[r3 + numDefine12];
                            heapClassInst.heap32[r2 + numDefine30] = heapClassInst.heap32[r3 + numDefine13];
                            heapClassInst.heap32[r2 + numDefine31] = heapClassInst.heap32[r3 + numDefine14];
                            heapClassInst.heap32[r2 + numDefine32] = heapClassInst.heap32[r3 + numDefine15];
                            r2 = heapClassInst.heap32[r1 + 1];
                            r2 = r2 >> numDefine2;
                            r3 = heapClassInst.heap32[r2 + numDefine48];
                            heapClassInst.heap32[r2 + numDefine48] = r4;
                            r2 = heapClassInst.heap32[r1 + numDefine6];
                            r4 = r0 << numDefine2;
                            r2 = (r2 + r4) | 0;
                            r2 = r2 >> numDefine2;
                            r5 = heapClassInst.heap32[r2];
                            if (!(r5 != 0)) {
                                r5 = heapClassInst.heap32[r1 + numDefine3];
                                r8 = r5 >> numDefine2;
                                r8 = heapClassInst.heap32[r8];
                                r8 = r8 >> numDefine2;
                                r8 = heapClassInst.heap32[r8 + numDefine2];
                                r11 = heapClassInst.heap32[r1 + numDefine7];
                                r12 = heapClassInst.heap32[r1 + numDefine2];
                                r13 = heapClassInst.heap32[r1 + 1];
                                heapClassInst.heap32[g0] = r5;
                                heapClassInst.heap32[g0 + 1] = r13;
                                heapClassInst.heap32[g0 + numDefine2] = r12;
                                heapClassInst.heap32[g0 + numDefine3] = r11;
                                functionTable.get(r8 >> numDefine2).accept(i7);
                                heapClassInst.heap32[r2] = commonVariable.rg0;
                            }
                            r2 = heapClassInst.heap32[r1 + numDefine5];
                            r5 = r2 >> numDefine2;
                            r8 = heapClassInst.heap32[r5];
                            r5 = heapClassInst.heap32[r5 + numDefine34];
                            r11 = heapClassInst.heap32[r1 + 1];
                            if (r5 != r11) {
                                r5 = r8 >> numDefine2;
                                r5 = heapClassInst.heap32[r5 + numDefine3];
                                heapClassInst.heap32[g0] = r2;
                                heapClassInst.heap32[g0 + 1] = -1;
                                heapClassInst.heap32[g0 + numDefine2] = r0;
                                functionTable.get(r5 >> numDefine2).accept(i7);
                            } else {
                                r8 = r8 >> numDefine2;
                                r8 = heapClassInst.heap32[r8 + numDefine2];
                                heapClassInst.heap32[g0] = r2;
                                heapClassInst.heap32[g0 + 1] = -1;
                                heapClassInst.heap32[g0 + numDefine2] = r0;
                                functionTable.get(r8 >> numDefine2).accept(i7);
                            }
                            r0 = heapClassInst.heap32[r1 + numDefine6];
                            r0 = (r0 + r4) | 0;
                            r0 = r0 >> numDefine2;
                            r0 = heapClassInst.heap32[r0];
                            r2 = r0 >> numDefine2;
                            r2 = heapClassInst.heap32[r2];
                            r2 = r2 >> numDefine2;
                            r2 = heapClassInst.heap32[r2 + numDefine2];
                            r4 = heapClassInst.heap32[r1 + numDefine5];
                            r5 = heapClassInst.heap32[r1 + numDefine4];
                            r8 = heapClassInst.heap32[r1 + numDefine2];
                            r11 = heapClassInst.heap32[r1 + 1];
                            heapClassInst.heap32[g0] = r0;
                            heapClassInst.heap32[g0 + 1] = r11;
                            heapClassInst.heap32[g0 + numDefine2] = r8;
                            heapClassInst.heap32[g0 + numDefine3] = r5;
                            heapClassInst.heap32[g0 + numDefine4] = r4;
                            functionTable.get(r2 >> numDefine2).accept(i7);
                            r0 = heapClassInst.heap32[r1 + numDefine4];
                            r0 = r0 >> numDefine2;
                            r0 = heapClassInst.heap32[r0 + numDefine5];
                            if (!(r0 == 0)) {
                                r2 = r0 >> numDefine2;
                                r2 = heapClassInst.heap32[r2];
                                r2 = r2 >> numDefine2;
                                r2 = heapClassInst.heap32[r2 + numDefine12];
                                heapClassInst.heap32[g0] = r0;
                                functionTable.get(r2 >> numDefine2).accept(i7);
                                r0 = commonVariable.rg0 & numDefine2;
                                if (!(r0 == 0)) {
                                    r0 = heapClassInst.heap32[r1 + numDefine4];
                                    r0 = r0 >> numDefine2;
                                    r2 = heapClassInst.heap32[r0 + numDefine5];
                                    r2 = r2 >> numDefine2;
                                    r2 = heapClassInst.heap32[r2];
                                    r2 = r2 >> numDefine2;
                                    r2 = heapClassInst.heap32[r2 + numDefine13];
                                    r4 = sp + numDefineNeg32;
                                    r5 = r4 >> numDefine2;
                                    heapClassInst.heap32[fp + numDefineNeg8] = numDefine53216;
                                    heapClassInst.heap32[r5 + 1] = numDefine53216;
                                    heapClassInst.heap32[r5 + numDefine2] = numDefine53216;
                                    heapClassInst.heap32[r5 + numDefine3] = 0;
                                    r0 = heapClassInst.heap32[r0 + numDefine5];
                                    heapClassInst.heap32[g0] = r0;
                                    heapClassInst.heap32[g0 + 1] = r6;
                                    heapClassInst.heap32[g0 + numDefine2] = r7;
                                    heapClassInst.heap32[g0 + numDefine3] = r4;
                                    functionTable.get(r2 >> numDefine2).accept(i7);
                                    r0 = heapClassInst.heap32[r1 + numDefine4];
                                    r0 = r0 >> numDefine2;
                                    r2 = heapClassInst.heap32[r0 + numDefine5];
                                    r2 = r2 >> numDefine2;
                                    r2 = heapClassInst.heap32[r2];
                                    r2 = r2 >> numDefine2;
                                    r2 = heapClassInst.heap32[r2 + numDefine13];
                                    r4 = sp + numDefineNeg16;
                                    r5 = r4 >> numDefine2;
                                    heapClassInst.heap32[fp + numDefineNeg4] = numDefine53216;
                                    heapClassInst.heap32[r5 + 1] = numDefine53216;
                                    heapClassInst.heap32[r5 + numDefine2] = numDefine53216;
                                    heapClassInst.heap32[r5 + numDefine3] = 0;
                                    r0 = heapClassInst.heap32[r0 + numDefine5];
                                    heapClassInst.heap32[g0] = r0;
                                    heapClassInst.heap32[g0 + 1] = r9;
                                    heapClassInst.heap32[g0 + numDefine2] = r10;
                                    heapClassInst.heap32[g0 + numDefine3] = r4;
                                    functionTable.get(r2 >> numDefine2).accept(i7);
                                }
                            }
                            r0 = heapClassInst.heap32[r1 + 1];
                            r0 = r0 >> numDefine2;
                            heapClassInst.heap32[r0 + numDefine48] = r3;
                            r0 = heapClassInst.heap32[r1 + 1];
                            r0 = r0 >> numDefine2;
                            heapClassInst.heapFloat[r0 + 1] = f0;
                            heapClassInst.heapFloat[r0 + numDefine2] = f2;
                            heapClassInst.heapFloat[r0 + numDefine3] = f6;
                            heapClassInst.heapFloat[r0 + numDefine4] = f23;
                            heapClassInst.heapFloat[r0 + numDefine5] = f10;
                            heapClassInst.heapFloat[r0 + numDefine6] = f11;
                            heapClassInst.heapFloat[r0 + numDefine7] = f18;
                            f0 = heapClassInst.heapFloat[fp + numDefineNeg59];
                            heapClassInst.heapFloat[r0 + numDefine8] = f0;
                            heapClassInst.heapFloat[r0 + numDefine9] = f12;
                            heapClassInst.heapFloat[r0 + numDefine10] = f15;
                            heapClassInst.heapFloat[r0 + numDefine11] = f20;
                            f0 = heapClassInst.heapFloat[fp + numDefineNeg57];
                            heapClassInst.heapFloat[r0 + numDefine12] = f0;
                            heapClassInst.heapFloat[r0 + numDefine13] = f24;
                            heapClassInst.heapFloat[r0 + numDefine14] = f25;
                            heapClassInst.heapFloat[r0 + numDefine15] = f26;
                            f0 = heapClassInst.heapFloat[fp + numDefineNeg58];
                            heapClassInst.heapFloat[r0 + numDefine16] = f0;
                            r0 = heapClassInst.heap32[r1 + 1];
                            r0 = r0 >> numDefine2;
                            f0 = heapClassInst.heapFloat[fp + numDefineNeg42];
                            heapClassInst.heapFloat[r0 + numDefine17] = f0;
                            f0 = heapClassInst.heapFloat[fp + numDefineNeg41];
                            heapClassInst.heapFloat[r0 + numDefine18] = f0;
                            f0 = heapClassInst.heapFloat[fp + numDefineNeg44];
                            heapClassInst.heapFloat[r0 + numDefine19] = f0;
                            f0 = heapClassInst.heapFloat[fp + numDefineNeg43];
                            heapClassInst.heapFloat[r0 + numDefine20] = f0;
                            f0 = heapClassInst.heapFloat[fp + numDefineNeg46];
                            heapClassInst.heapFloat[r0 + numDefine21] = f0;
                            f0 = heapClassInst.heapFloat[fp + numDefineNeg45];
                            heapClassInst.heapFloat[r0 + numDefine22] = f0;
                            f0 = heapClassInst.heapFloat[fp + numDefineNeg48];
                            heapClassInst.heapFloat[r0 + numDefine23] = f0;
                            f0 = heapClassInst.heapFloat[fp + numDefineNeg47];
                            heapClassInst.heapFloat[r0 + numDefine24] = f0;
                            f0 = heapClassInst.heapFloat[fp + numDefineNeg50];
                            heapClassInst.heapFloat[r0 + numDefine25] = f0;
                            f0 = heapClassInst.heapFloat[fp + numDefineNeg49];
                            heapClassInst.heapFloat[r0 + numDefine26] = f0;
                            f0 = heapClassInst.heapFloat[fp + numDefineNeg52];
                            heapClassInst.heapFloat[r0 + numDefine27] = f0;
                            f0 = heapClassInst.heapFloat[fp + numDefineNeg51];
                            heapClassInst.heapFloat[r0 + numDefine28] = f0;
                            f0 = heapClassInst.heapFloat[fp + numDefineNeg54];
                            heapClassInst.heapFloat[r0 + numDefine29] = f0;
                            f0 = heapClassInst.heapFloat[fp + numDefineNeg53];
                            heapClassInst.heapFloat[r0 + numDefine30] = f0;
                            f0 = heapClassInst.heapFloat[fp + numDefineNeg56];
                            heapClassInst.heapFloat[r0 + numDefine31] = f0;
                            f0 = heapClassInst.heapFloat[fp + numDefineNeg55];
                            heapClassInst.heapFloat[r0 + numDefine32] = f0;
                        }
                    }
                }
                return;
            } else {
                r0 = twoEStr7106;
                r1 = twoEStr1100;
                heapClassInst.heap32[g0] = r0;
                heapClassInst.heap32[g0 + 1] = r1;
                heapClassInst.heap32[g0 + numDefine2] = numDefine119;
                assertNew(i7);
            }
        } else {
            r0 = twoEStr6105;
            r1 = twoEStr1100;
            heapClassInst.heap32[g0] = r0;
            heapClassInst.heap32[g0 + 1] = r1;
            heapClassInst.heap32[g0 + numDefine2] = numDefine117;
            assertNew(i7);
        }
    }

    public static void zn28btCompoundCollisionAlgorithm16processCollisionEP17btCollisionObjectS1RK16btDispatcherInfoP16btManifoldResult(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        int r6 = 0;
        int r7 = 0;
        int r8 = 0;
        int r9 = 0;
        int r10 = 0;
        int r11 = 0;
        int r12 = 0;
        int r13 = 0;
        int r14 = 0;
        int r15 = 0;
        int r16 = 0;
        int r17 = 0;
        float f0 = 0.0F;
        float f1 = 0.0F;
        float f2 = 0.0F;
        float f3 = 0.0F;
        float f4 = 0.0F;
        float f5 = 0.0F;
        float f6 = 0.0F;
        float f7 = 0.0F;
        float f8 = 0.0F;
        float f9 = 0.0F;
        float f10 = 0.0F;
        float f11 = 0.0F;
        float f12 = 0.0F;
        float f13 = 0.0F;
        float f14 = 0.0F;
        float f15 = 0.0F;
        float f16 = 0.0F;
        float f17 = 0.0F;
        float f18 = 0.0F;
        float f19 = 0.0F;
        float f20 = 0.0F;
        float f21 = 0.0F;
        float f22 = 0.0F;
        float f23 = 0.0F;
        float f24 = 0.0F;
        float f25 = 0.0F;
        float f26 = 0.0F;
        float f27 = 0.0F;
        float f28 = 0.0F;
        float f29 = 0.0F;
        int label = 0;
        i7 = sp + numDefineNeg328;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = heapClassInst.heap32[fp + 1];
        r2 = heapClassInst.heap32[fp + numDefine2];
        r3 = heapClassInst.heapU8[r0 + numDefine28];
        r4 = r3 == 0 ? r1 : r2;
        r5 = r4 >> numDefine2;
        r6 = heapClassInst.heap32[r5 + numDefine48];
        r6 = r6 >> numDefine2;
        r7 = heapClassInst.heap32[r6 + 1];
        if (r7 == numDefine31) {
            r7 = r0 >> numDefine2;
            r8 = heapClassInst.heap32[r6 + numDefine17];
            r9 = heapClassInst.heap32[r7 + numDefine10];
            if (!(r8 == r9)) {
                r8 = heapClassInst.heap32[r7 + numDefine3];
                if (!(r8 < 1)) {
                    r9 = 0;
                    repeat7:
                    while (true) {
                        r10 = heapClassInst.heap32[r7 + numDefine5];
                        r11 = r9 << numDefine2;
                        r10 = (r10 + r11) | 0;
                        r10 = r10 >> numDefine2;
                        r10 = heapClassInst.heap32[r10];
                        if (!(r10 == 0)) {
                            r12 = r10 >> numDefine2;
                            r12 = heapClassInst.heap32[r12];
                            r12 = r12 >> numDefine2;
                            r12 = heapClassInst.heap32[r12];
                            heapClassInst.heap32[g0] = r10;
                            functionTable.get(r12 >> numDefine2).accept(i7);
                            r10 = heapClassInst.heap32[r7 + 1];
                            r12 = r10 >> numDefine2;
                            r13 = heapClassInst.heap32[r7 + numDefine5];
                            r11 = (r13 + r11) | 0;
                            r12 = heapClassInst.heap32[r12];
                            r12 = r12 >> numDefine2;
                            r11 = r11 >> numDefine2;
                            r12 = heapClassInst.heap32[r12 + numDefine13];
                            r11 = heapClassInst.heap32[r11];
                            heapClassInst.heap32[g0] = r10;
                            heapClassInst.heap32[g0 + 1] = r11;
                            functionTable.get(r12 >> numDefine2).accept(i7);
                        }
                        r9 = (r9 + 1) | 0;
                        if (!(r8 != r9)) {
                            break repeat7;
                        }
                    }
                }
                heapClassInst.heap32[g0] = r0;
                heapClassInst.heap32[g0 + 1] = r1;
                heapClassInst.heap32[g0 + numDefine2] = r2;
                zn28btCompoundCollisionAlgorithm26preallocateChildAlgorithmsEP17btCollisionObjectS1(i7);
            }
            r0 = heapClassInst.heap32[fp + numDefine3];
            r8 = heapClassInst.heap32[fp + numDefine4];
            r1 = r3 == 0 ? r2 : r1;
            r2 = ztv22btCompoundLeafCallback;
            r3 = heapClassInst.heap32[r6 + numDefine16];
            r9 = heapClassInst.heap32[r7 + numDefine8];
            r10 = heapClassInst.heap32[r7 + numDefine5];
            r11 = heapClassInst.heap32[r7 + 1];
            r12 = sp + numDefineNeg32;
            r2 = (r2 + numDefine8) | 0;
            r13 = r12 >> numDefine2;
            heapClassInst.heap32[fp + numDefineNeg8] = r2;
            heapClassInst.heap32[r13 + 1] = r4;
            heapClassInst.heap32[r13 + numDefine2] = r1;
            heapClassInst.heap32[r13 + numDefine3] = r11;
            heapClassInst.heap32[r13 + numDefine4] = r0;
            heapClassInst.heap32[r13 + numDefine5] = r8;
            heapClassInst.heap32[r13 + numDefine6] = r10;
            r0 = sp + numDefineNeg56;
            r2 = 1;
            heapClassInst.heap32[r13 + numDefine7] = r9;
            r4 = r0 >> numDefine2;
            heapClassInst.heap8[sp + numDefineNeg40] = (byte) r2;
            heapClassInst.heap32[r4 + numDefine3] = 0;
            r9 = (r8 + numDefine72) | 0;
            r10 = (r8 + numDefine8) | 0;
            r11 = 0;
            heapClassInst.heap32[r4 + 1] = 0;
            heapClassInst.heap32[r4 + numDefine2] = 0;
            repeat14:
            while (true) {
                r13 = heapClassInst.heap32[r7 + numDefine3];
                if (r13 > r11) {
                    r13 = heapClassInst.heap32[r7 + numDefine5];
                    r14 = r11 << numDefine2;
                    r13 = (r13 + r14) | 0;
                    r13 = r13 >> numDefine2;
                    r13 = heapClassInst.heap32[r13];
                    if (!(r13 == 0)) {
                        r14 = r13 >> numDefine2;
                        r14 = heapClassInst.heap32[r14];
                        r14 = r14 >> numDefine2;
                        r14 = heapClassInst.heap32[r14 + numDefine4];
                        heapClassInst.heap32[g0] = r13;
                        heapClassInst.heap32[g0 + 1] = r0;
                        r13 = 0;
                        functionTable.get(r14 >> numDefine2).accept(i7);
                        repeat19:
                        while (true) {
                            r14 = heapClassInst.heap32[r4 + numDefine3];
                            r15 = heapClassInst.heap32[r4 + 1];
                            if (r15 > r13) {
                                r15 = r13 << numDefine2;
                                r14 = (r14 + r15) | 0;
                                r14 = r14 >> numDefine2;
                                r14 = heapClassInst.heap32[r14];
                                r15 = r14 >> numDefine2;
                                r16 = heapClassInst.heap32[r15 + numDefine279];
                                if (!(r16 == 0)) {
                                    r16 = r8 >> numDefine2;
                                    heapClassInst.heap32[r16 + 1] = r14;
                                    if (r14 != 0) {
                                        r17 = heapClassInst.heap32[r15 + numDefine279];
                                        if (!(r17 == 0)) {
                                            r15 = heapClassInst.heap32[r15 + numDefine277];
                                            r17 = heapClassInst.heap32[r16 + numDefine34];
                                            if (r15 == r17) {
                                                heapClassInst.heap32[g0] = r14;
                                                heapClassInst.heap32[g0 + 1] = r10;
                                                heapClassInst.heap32[g0 + numDefine2] = r9;
                                                zn20btPersistentManifold20refreshContactPointsERK11btTransformS2(i7);
                                            } else {
                                                heapClassInst.heap32[g0] = r14;
                                                heapClassInst.heap32[g0 + 1] = r9;
                                                heapClassInst.heap32[g0 + numDefine2] = r10;
                                                zn20btPersistentManifold20refreshContactPointsERK11btTransformS2(i7);
                                            }
                                        }
                                        heapClassInst.heap32[r16 + 1] = 0;
                                    } else {
                                        label = numDefine14;
                                        break repeat14;
                                    }
                                }
                                r13 = (r13 + 1) | 0;
                            } else {
                                break repeat19;
                            }
                        }
                        if (!(r14 == 0)) {
                            r13 = heapClassInst.heapU8[sp + numDefineNeg40];
                            if (!(r13 == 0)) {
                                r13 = gNumAlignedFree;
                                r13 = r13 >> numDefine2;
                                r15 = heapClassInst.heap32[r13];
                                r15 = (r15 + 1) | 0;
                                r14 = r14 >> numDefine2;
                                heapClassInst.heap32[r13] = r15;
                                r13 = heapClassInst.heap32[r14 + -1];
                                heapClassInst.heap32[g0] = r13;
                                free(i7);
                            }
                            heapClassInst.heap32[r4 + numDefine3] = 0;
                        }
                        r13 = 1;
                        heapClassInst.heap8[sp + numDefineNeg40] = (byte) r13;
                        heapClassInst.heap32[r4 + numDefine3] = 0;
                        heapClassInst.heap32[r4 + 1] = 0;
                        heapClassInst.heap32[r4 + numDefine2] = 0;
                    }
                    r11 = (r11 + 1) | 0;
                } else {
                    label = numDefine29;
                    break repeat14;
                }
            }
            switch (label) {
                case numDefine29:
                    heapClassInst.heap8[sp + numDefineNeg40] = (byte) r2;
                    heapClassInst.heap32[r4 + numDefine3] = 0;
                    heapClassInst.heap32[r4 + 1] = 0;
                    heapClassInst.heap32[r4 + numDefine2] = 0;
                    repeat42:
                    do {
                        if (r3 == 0) {
                            if (r13 < 1) {
                                label = numDefine49;
                            } else {
                                r0 = 0;
                                while (true) {
                                    r3 = (r0 * numDefine20) | 0;
                                    r4 = heapClassInst.heap32[r6 + numDefine6];
                                    r3 = r3 << numDefine2;
                                    r3 = (r4 + r3) | 0;
                                    r3 = r3 >> numDefine2;
                                    r3 = heapClassInst.heap32[r3 + numDefine16];
                                    heapClassInst.heap32[g0] = r12;
                                    heapClassInst.heap32[g0 + 1] = r3;
                                    heapClassInst.heap32[g0 + numDefine2] = r0;
                                    r0 = (r0 + 1) | 0;
                                    zn22btCompoundLeafCallback17ProcessChildShapeEP16btCollisionShapei(i7);
                                    if (!(r13 != r0)) {
                                        label = numDefine34;
                                        break repeat42;
                                    }
                                }
                            }
                        } else {
                            r13 = r1 >> numDefine2;
                            f0 = heapClassInst.heapFloat[r5 + 1];
                            f1 = heapClassInst.heapFloat[r13 + 1];
                            f2 = heapClassInst.heapFloat[r5 + numDefine5];
                            f3 = heapClassInst.heapFloat[r13 + numDefine5];
                            f4 = heapClassInst.heapFloat[r13 + numDefine2];
                            f5 = heapClassInst.heapFloat[r13 + numDefine6];
                            f6 = f1 * f0;
                            f7 = f3 * f2;
                            f8 = heapClassInst.heapFloat[r5 + numDefine9];
                            f9 = heapClassInst.heapFloat[r13 + numDefine9];
                            f10 = heapClassInst.heapFloat[r5 + numDefine2];
                            f11 = heapClassInst.heapFloat[r5 + numDefine6];
                            f12 = heapClassInst.heapFloat[r5 + numDefine3];
                            f13 = heapClassInst.heapFloat[r13 + numDefine13];
                            f14 = heapClassInst.heapFloat[r13 + numDefine3];
                            f15 = heapClassInst.heapFloat[r5 + numDefine7];
                            f16 = heapClassInst.heapFloat[r5 + numDefine14];
                            f17 = heapClassInst.heapFloat[r13 + numDefine14];
                            f18 = heapClassInst.heapFloat[r13 + numDefine7];
                            f19 = heapClassInst.heapFloat[r5 + numDefine10];
                            f20 = heapClassInst.heapFloat[r5 + numDefine15];
                            f21 = heapClassInst.heapFloat[r5 + numDefine11];
                            f22 = heapClassInst.heapFloat[r13 + numDefine15];
                            f23 = heapClassInst.heapFloat[r13 + numDefine11];
                            f24 = heapClassInst.heapFloat[r13 + numDefine10];
                            f25 = heapClassInst.heapFloat[r5 + numDefine13];
                            f26 = f4 * f0;
                            f27 = f5 * f2;
                            f6 = f6 + f7;
                            f7 = f9 * f8;
                            r0 = sp + numDefineNeg152;
                            f28 = f14 * f0;
                            f29 = f18 * f2;
                            f26 = f26 + f27;
                            f27 = f24 * f8;
                            f6 = f6 + f7;
                            r4 = r0 >> numDefine2;
                            f7 = f28 + f29;
                            f28 = f23 * f8;
                            f26 = f26 + f27;
                            heapClassInst.heapFloat[fp + numDefineNeg38] = f6;
                            f6 = f1 * f10;
                            f27 = f3 * f11;
                            f7 = f7 + f28;
                            heapClassInst.heapFloat[r4 + 1] = f26;
                            heapClassInst.heapFloat[r4 + numDefine2] = f7;
                            f7 = f4 * f10;
                            f26 = f5 * f11;
                            f6 = f6 + f27;
                            f27 = f9 * f19;
                            f28 = f14 * f10;
                            f29 = f18 * f11;
                            f7 = f7 + f26;
                            f26 = f24 * f19;
                            f6 = f6 + f27;
                            heapClassInst.heap32[r4 + numDefine3] = 0;
                            f27 = f28 + f29;
                            f28 = f23 * f19;
                            f7 = f7 + f26;
                            heapClassInst.heapFloat[r4 + numDefine4] = f6;
                            f1 = f1 * f12;
                            f3 = f3 * f15;
                            f6 = f27 + f28;
                            heapClassInst.heapFloat[r4 + numDefine5] = f7;
                            heapClassInst.heapFloat[r4 + numDefine6] = f6;
                            f4 = f4 * f12;
                            f5 = f5 * f15;
                            f1 = f1 + f3;
                            f3 = f9 * f21;
                            f6 = -f25;
                            f7 = f14 * f12;
                            f9 = f18 * f15;
                            f4 = f4 + f5;
                            f5 = f24 * f21;
                            f1 = f1 + f3;
                            heapClassInst.heap32[r4 + numDefine7] = 0;
                            f3 = f0 * f13;
                            f14 = f2 * f17;
                            f0 = f0 * f6;
                            f2 = f2 * f16;
                            f7 = f7 + f9;
                            f9 = f23 * f21;
                            f4 = f4 + f5;
                            heapClassInst.heapFloat[r4 + numDefine8] = f1;
                            f1 = f10 * f13;
                            f5 = f11 * f17;
                            f10 = f10 * f6;
                            f11 = f11 * f16;
                            f3 = f3 + f14;
                            f14 = f8 * f22;
                            f0 = f0 - f2;
                            f2 = f8 * f20;
                            f7 = f7 + f9;
                            heapClassInst.heapFloat[r4 + numDefine9] = f4;
                            heapClassInst.heapFloat[r4 + numDefine10] = f7;
                            f4 = f12 * f13;
                            f7 = f15 * f17;
                            f6 = f12 * f6;
                            f8 = f15 * f16;
                            f1 = f1 + f5;
                            f5 = f19 * f22;
                            f9 = f10 - f11;
                            f10 = f19 * f20;
                            f3 = f3 + f14;
                            f0 = f0 - f2;
                            f2 = f4 + f7;
                            f4 = f21 * f22;
                            f6 = f6 - f8;
                            f7 = f21 * f20;
                            f1 = f1 + f5;
                            f5 = f9 - f10;
                            f0 = f3 + f0;
                            heapClassInst.heap32[r4 + numDefine11] = 0;
                            f2 = f2 + f4;
                            f3 = f6 - f7;
                            f1 = f1 + f5;
                            heapClassInst.heapFloat[r4 + numDefine12] = f0;
                            f0 = f2 + f3;
                            heapClassInst.heapFloat[r4 + numDefine13] = f1;
                            heapClassInst.heapFloat[r4 + numDefine14] = f0;
                            heapClassInst.heap32[r4 + numDefine15] = 0;
                            r13 = heapClassInst.heap32[r13 + numDefine48];
                            r4 = r13 >> numDefine2;
                            r4 = heapClassInst.heap32[r4];
                            r4 = r4 >> numDefine2;
                            r4 = heapClassInst.heap32[r4 + numDefine2];
                            r8 = sp + numDefineNeg72;
                            r9 = sp + numDefineNeg88;
                            heapClassInst.heap32[g0] = r13;
                            heapClassInst.heap32[g0 + 1] = r0;
                            heapClassInst.heap32[g0 + numDefine2] = r8;
                            heapClassInst.heap32[g0 + numDefine3] = r9;
                            r13 = sp + numDefineNeg184;
                            functionTable.get(r4 >> numDefine2).accept(i7);
                            r0 = r13 >> numDefine2;
                            r4 = r8 >> numDefine2;
                            heapClassInst.heap32[fp + numDefineNeg46] = heapClassInst.heap32[fp + numDefineNeg18];
                            heapClassInst.heap32[r0 + 1] = heapClassInst.heap32[r4 + 1];
                            heapClassInst.heap32[r0 + numDefine2] = heapClassInst.heap32[r4 + numDefine2];
                            heapClassInst.heap32[r0 + numDefine3] = heapClassInst.heap32[r4 + numDefine3];
                            r4 = r9 >> numDefine2;
                            heapClassInst.heap32[r0 + numDefine4] = heapClassInst.heap32[fp + numDefineNeg22];
                            heapClassInst.heap32[r0 + numDefine5] = heapClassInst.heap32[r4 + 1];
                            heapClassInst.heap32[r0 + numDefine6] = heapClassInst.heap32[r4 + numDefine2];
                            r3 = r3 >> numDefine2;
                            heapClassInst.heap32[r0 + numDefine7] = heapClassInst.heap32[r4 + numDefine3];
                            r0 = heapClassInst.heap32[r3];
                            heapClassInst.heap32[g0] = r0;
                            heapClassInst.heap32[g0 + 1] = r13;
                            heapClassInst.heap32[g0 + numDefine2] = r12;
                            zn6btDbvt9collideTVEPK10btDbvtNodeRK12btDbvtAabbMmRNS8ICollideE(i7);
                            label = numDefine34;
                        }
                    } while (false);
                    repeat48:
                    do {
                        if (label == numDefine34) {
                            r0 = heapClassInst.heap32[r7 + numDefine3];
                            if (!(r0 < 1)) {
                                r3 = 0;
                                r4 = (r1 + numDefine4) | 0;
                                r0 = (r3 - r0) | 0;
                                while (true) {
                                    r8 = heapClassInst.heap32[r7 + numDefine5];
                                    r9 = r3 << numDefine2;
                                    r8 = (r8 - r9) | 0;
                                    r8 = r8 >> numDefine2;
                                    r8 = heapClassInst.heap32[r8];
                                    repeat53:
                                    do {
                                        if (!(r8 == 0)) {
                                            r8 = (r3 * numDefineNeg20) | 0;
                                            r10 = heapClassInst.heap32[r6 + numDefine6];
                                            r8 = r8 << numDefine2;
                                            r8 = (r10 + r8) | 0;
                                            r8 = r8 >> numDefine2;
                                            f0 = heapClassInst.heapFloat[r5 + 1];
                                            f1 = heapClassInst.heapFloat[r8];
                                            f2 = heapClassInst.heapFloat[r5 + numDefine2];
                                            f3 = heapClassInst.heapFloat[r8 + numDefine4];
                                            f4 = heapClassInst.heapFloat[r8 + 1];
                                            f5 = heapClassInst.heapFloat[r8 + numDefine5];
                                            f6 = f1 * f0;
                                            f7 = f3 * f2;
                                            f8 = heapClassInst.heapFloat[r5 + numDefine3];
                                            f9 = heapClassInst.heapFloat[r8 + numDefine8];
                                            f10 = heapClassInst.heapFloat[r5 + numDefine5];
                                            f11 = heapClassInst.heapFloat[r5 + numDefine6];
                                            f12 = heapClassInst.heapFloat[r5 + numDefine9];
                                            f13 = heapClassInst.heapFloat[r8 + numDefine12];
                                            f14 = heapClassInst.heapFloat[r8 + numDefine2];
                                            f15 = heapClassInst.heapFloat[r5 + numDefine10];
                                            f16 = heapClassInst.heapFloat[r8 + numDefine13];
                                            f17 = heapClassInst.heapFloat[r8 + numDefine6];
                                            r10 = heapClassInst.heap32[r8 + numDefine16];
                                            f18 = heapClassInst.heapFloat[r5 + numDefine7];
                                            f19 = heapClassInst.heapFloat[r8 + numDefine14];
                                            f20 = heapClassInst.heapFloat[r5 + numDefine11];
                                            f21 = heapClassInst.heapFloat[r8 + numDefine10];
                                            f22 = heapClassInst.heapFloat[r8 + numDefine9];
                                            f23 = f4 * f0;
                                            f24 = f5 * f2;
                                            f6 = f6 + f7;
                                            f7 = f9 * f8;
                                            f25 = heapClassInst.heapFloat[r5 + numDefine13];
                                            f26 = heapClassInst.heapFloat[r5 + numDefine14];
                                            f27 = heapClassInst.heapFloat[r5 + numDefine15];
                                            r8 = sp + numDefineNeg248;
                                            f28 = f14 * f0;
                                            f29 = f17 * f2;
                                            f23 = f23 + f24;
                                            f24 = f22 * f8;
                                            f6 = f6 + f7;
                                            r11 = r8 >> numDefine2;
                                            f7 = f28 + f29;
                                            f28 = f21 * f8;
                                            f23 = f23 + f24;
                                            heapClassInst.heapFloat[fp + numDefineNeg62] = f6;
                                            f6 = f1 * f10;
                                            f24 = f3 * f11;
                                            f7 = f7 + f28;
                                            heapClassInst.heapFloat[r11 + 1] = f23;
                                            heapClassInst.heapFloat[r11 + numDefine2] = f7;
                                            f7 = f4 * f10;
                                            f23 = f5 * f11;
                                            f6 = f6 + f24;
                                            f24 = f9 * f18;
                                            f28 = f14 * f10;
                                            f29 = f17 * f11;
                                            f7 = f7 + f23;
                                            f23 = f22 * f18;
                                            f6 = f6 + f24;
                                            heapClassInst.heap32[r11 + numDefine3] = 0;
                                            f24 = f28 + f29;
                                            f28 = f21 * f18;
                                            f7 = f7 + f23;
                                            heapClassInst.heapFloat[r11 + numDefine4] = f6;
                                            f1 = f1 * f12;
                                            f3 = f3 * f15;
                                            f6 = f24 + f28;
                                            heapClassInst.heapFloat[r11 + numDefine5] = f7;
                                            heapClassInst.heapFloat[r11 + numDefine6] = f6;
                                            f4 = f4 * f12;
                                            f5 = f5 * f15;
                                            f1 = f1 + f3;
                                            f3 = f9 * f20;
                                            f6 = f14 * f12;
                                            f7 = f17 * f15;
                                            f4 = f4 + f5;
                                            f5 = f22 * f20;
                                            f1 = f1 + f3;
                                            heapClassInst.heap32[r11 + numDefine7] = 0;
                                            f0 = f0 * f13;
                                            f2 = f2 * f16;
                                            f3 = f6 + f7;
                                            f6 = f21 * f20;
                                            f4 = f4 + f5;
                                            heapClassInst.heapFloat[r11 + numDefine8] = f1;
                                            f1 = f10 * f13;
                                            f5 = f11 * f16;
                                            f0 = f0 + f2;
                                            f2 = f8 * f19;
                                            f3 = f3 + f6;
                                            heapClassInst.heapFloat[r11 + numDefine9] = f4;
                                            f0 = f0 + f2;
                                            heapClassInst.heapFloat[r11 + numDefine10] = f3;
                                            f2 = f12 * f13;
                                            f3 = f15 * f16;
                                            f1 = f1 + f5;
                                            f4 = f18 * f19;
                                            f1 = f1 + f4;
                                            f2 = f2 + f3;
                                            f3 = f20 * f19;
                                            f0 = f0 + f25;
                                            heapClassInst.heap32[r11 + numDefine11] = 0;
                                            f2 = f2 + f3;
                                            f1 = f1 + f26;
                                            heapClassInst.heapFloat[r11 + numDefine12] = f0;
                                            f0 = f2 + f27;
                                            heapClassInst.heapFloat[r11 + numDefine13] = f1;
                                            heapClassInst.heapFloat[r11 + numDefine14] = f0;
                                            r12 = r10 >> numDefine2;
                                            heapClassInst.heap32[r11 + numDefine15] = 0;
                                            r11 = heapClassInst.heap32[r12];
                                            r11 = r11 >> numDefine2;
                                            r11 = heapClassInst.heap32[r11 + numDefine2];
                                            r12 = sp + numDefineNeg264;
                                            r13 = sp + numDefineNeg280;
                                            heapClassInst.heap32[g0] = r10;
                                            heapClassInst.heap32[g0 + 1] = r8;
                                            heapClassInst.heap32[g0 + numDefine2] = r12;
                                            heapClassInst.heap32[g0 + numDefine3] = r13;
                                            functionTable.get(r11 >> numDefine2).accept(i7);
                                            r8 = r1 >> numDefine2;
                                            r8 = heapClassInst.heap32[r8 + numDefine48];
                                            r10 = r8 >> numDefine2;
                                            r10 = heapClassInst.heap32[r10];
                                            r10 = r10 >> numDefine2;
                                            r10 = heapClassInst.heap32[r10 + numDefine2];
                                            r11 = sp + numDefineNeg296;
                                            r14 = sp + numDefineNeg312;
                                            heapClassInst.heap32[g0] = r8;
                                            heapClassInst.heap32[g0 + 1] = r4;
                                            heapClassInst.heap32[g0 + numDefine2] = r11;
                                            heapClassInst.heap32[g0 + numDefine3] = r14;
                                            functionTable.get(r10 >> numDefine2).accept(i7);
                                            f0 = heapClassInst.heapFloat[fp + numDefineNeg66];
                                            f1 = heapClassInst.heapFloat[fp + numDefineNeg78];
                                            if (f0 > f1) {
                                                label = numDefine40;
                                            } else {
                                                f0 = heapClassInst.heapFloat[fp + numDefineNeg70];
                                                f1 = heapClassInst.heapFloat[fp + numDefineNeg74];
                                                if (f0 < f1) {
                                                    label = numDefine40;
                                                } else {
                                                    r8 = r2;
                                                    label = numDefine41;
                                                }
                                            }
                                            if (label == numDefine40) {
                                                r8 = 0;
                                            }
                                            r10 = r12 >> numDefine2;
                                            r12 = r14 >> numDefine2;
                                            f0 = heapClassInst.heapFloat[r10 + numDefine2];
                                            f1 = heapClassInst.heapFloat[r12 + numDefine2];
                                            if (f0 > f1) {
                                                label = numDefine43;
                                            } else {
                                                r14 = r13 >> numDefine2;
                                                r15 = r11 >> numDefine2;
                                                f0 = heapClassInst.heapFloat[r14 + numDefine2];
                                                f1 = heapClassInst.heapFloat[r15 + numDefine2];
                                                if (f0 < f1) {
                                                    label = numDefine43;
                                                } else {
                                                    label = numDefine44;
                                                }
                                            }
                                            if (label == numDefine43) {
                                                r8 = 0;
                                            }
                                            f0 = heapClassInst.heapFloat[r10 + 1];
                                            f1 = heapClassInst.heapFloat[r12 + 1];
                                            if (!(f0 > f1)) {
                                                r10 = r13 >> numDefine2;
                                                r11 = r11 >> numDefine2;
                                                f0 = heapClassInst.heapFloat[r10 + 1];
                                                f1 = heapClassInst.heapFloat[r11 + 1];
                                                if (!(f0 < f1)) {
                                                    r8 = r8 & numDefine255;
                                                    if (r8 != 0) {
                                                        break repeat53;
                                                    }
                                                }
                                            }
                                            r8 = heapClassInst.heap32[r7 + numDefine5];
                                            r8 = (r8 - r9) | 0;
                                            r8 = r8 >> numDefine2;
                                            r8 = heapClassInst.heap32[r8];
                                            r10 = r8 >> numDefine2;
                                            r10 = heapClassInst.heap32[r10];
                                            r10 = r10 >> numDefine2;
                                            r10 = heapClassInst.heap32[r10];
                                            heapClassInst.heap32[g0] = r8;
                                            functionTable.get(r10 >> numDefine2).accept(i7);
                                            r8 = heapClassInst.heap32[r7 + 1];
                                            r10 = r8 >> numDefine2;
                                            r11 = heapClassInst.heap32[r7 + numDefine5];
                                            r11 = (r11 - r9) | 0;
                                            r10 = heapClassInst.heap32[r10];
                                            r10 = r10 >> numDefine2;
                                            r11 = r11 >> numDefine2;
                                            r10 = heapClassInst.heap32[r10 + numDefine13];
                                            r11 = heapClassInst.heap32[r11];
                                            heapClassInst.heap32[g0] = r8;
                                            heapClassInst.heap32[g0 + 1] = r11;
                                            functionTable.get(r10 >> numDefine2).accept(i7);
                                            r8 = heapClassInst.heap32[r7 + numDefine5];
                                            r8 = (r8 - r9) | 0;
                                            r8 = r8 >> numDefine2;
                                            heapClassInst.heap32[r8] = 0;
                                        }
                                    } while (false);
                                    r3 = (r3 + -1) | 0;
                                    if (!(r0 != r3)) {
                                        break repeat48;
                                    }
                                }
                            }
                        }
                    } while (false);
                    
                case numDefine14:
                    r14 = twoEStr59;
                    r0 = twoEStr160;
                    heapClassInst.heap32[g0] = r14;
                    heapClassInst.heap32[g0 + 1] = r0;
                    heapClassInst.heap32[g0 + numDefine2] = numDefine101;
                    assertNew(i7);
                    break;
                default:
                    break;
            }
        } else {
            r0 = twoEStr99;
            r1 = twoEStr1100;
            heapClassInst.heap32[g0] = r0;
            heapClassInst.heap32[g0 + 1] = r1;
            heapClassInst.heap32[g0 + numDefine2] = numDefine199;
            assertNew(i7);
        }
        
    }
}
